LCOV - code coverage report
Current view: directory - storage/src - mozStorageRow.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 85 77 90.6 %
Date: 2012-06-02 Functions: 18 15 83.3 %

       1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
       2                 :  * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
       3                 :  * ***** BEGIN LICENSE BLOCK *****
       4                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
       5                 :  *
       6                 :  * The contents of this file are subject to the Mozilla Public License Version
       7                 :  * 1.1 (the "License"); you may not use this file except in compliance with
       8                 :  * the License. You may obtain a copy of the License at
       9                 :  * http://www.mozilla.org/MPL/
      10                 :  *
      11                 :  * Software distributed under the License is distributed on an "AS IS" basis,
      12                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
      13                 :  * for the specific language governing rights and limitations under the
      14                 :  * License.
      15                 :  *
      16                 :  * The Original Code is mozilla.org code.
      17                 :  *
      18                 :  * The Initial Developer of the Original Code is
      19                 :  * Mozilla Corporation
      20                 :  * Portions created by the Initial Developer are Copyright (C) 2008
      21                 :  * the Initial Developer. All Rights Reserved.
      22                 :  *
      23                 :  * Contributor(s):
      24                 :  *   Shawn Wilsher <me@shawnwilsher.com> (Original Author)
      25                 :  *
      26                 :  * Alternatively, the contents of this file may be used under the terms of
      27                 :  * either the GNU General Public License Version 2 or later (the "GPL"), or
      28                 :  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
      29                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
      30                 :  * of those above. If you wish to allow use of your version of this file only
      31                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
      32                 :  * use your version of this file under the terms of the MPL, indicate your
      33                 :  * decision by deleting the provisions above and replace them with the notice
      34                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
      35                 :  * the provisions above, a recipient may use your version of this file under
      36                 :  * the terms of any one of the MPL, the GPL or the LGPL.
      37                 :  *
      38                 :  * ***** END LICENSE BLOCK ***** */
      39                 : 
      40                 : #include "nsString.h"
      41                 : 
      42                 : #include "sqlite3.h"
      43                 : #include "mozStoragePrivateHelpers.h"
      44                 : #include "Variant.h"
      45                 : #include "mozStorageRow.h"
      46                 : 
      47                 : namespace mozilla {
      48                 : namespace storage {
      49                 : 
      50                 : ////////////////////////////////////////////////////////////////////////////////
      51                 : //// Row
      52                 : 
      53                 : nsresult
      54           24433 : Row::initialize(sqlite3_stmt *aStatement)
      55                 : {
      56                 :   // Initialize the hash table
      57           24433 :   NS_ENSURE_TRUE(mNameHashtable.Init(), NS_ERROR_OUT_OF_MEMORY);
      58                 : 
      59                 :   // Get the number of results
      60           24433 :   mNumCols = ::sqlite3_column_count(aStatement);
      61                 : 
      62                 :   // Start copying over values
      63          311198 :   for (PRUint32 i = 0; i < mNumCols; i++) {
      64                 :     // Store the value
      65          286765 :     nsIVariant *variant = nsnull;
      66          286765 :     int type = ::sqlite3_column_type(aStatement, i);
      67          286765 :     switch (type) {
      68                 :       case SQLITE_INTEGER:
      69          274112 :         variant = new IntegerVariant(::sqlite3_column_int64(aStatement, i));
      70          137056 :         break;
      71                 :       case SQLITE_FLOAT:
      72              68 :         variant = new FloatVariant(::sqlite3_column_double(aStatement, i));
      73              34 :         break;
      74                 :       case SQLITE_TEXT:
      75                 :       {
      76                 :         nsDependentString str(
      77          106644 :           static_cast<const PRUnichar *>(::sqlite3_column_text16(aStatement, i))
      78          213288 :         );
      79          106644 :         variant = new TextVariant(str);
      80                 :         break;
      81                 :       }
      82                 :       case SQLITE_NULL:
      83           43002 :         variant = new NullVariant();
      84           43002 :         break;
      85                 :       case SQLITE_BLOB:
      86                 :       {
      87              29 :         int size = ::sqlite3_column_bytes(aStatement, i);
      88              29 :         const void *data = ::sqlite3_column_blob(aStatement, i);
      89              58 :         variant = new BlobVariant(std::pair<const void *, int>(data, size));
      90              29 :         break;
      91                 :       }
      92                 :       default:
      93               0 :         return NS_ERROR_UNEXPECTED;
      94                 :     }
      95          286765 :     NS_ENSURE_TRUE(variant, NS_ERROR_OUT_OF_MEMORY);
      96                 : 
      97                 :     // Insert into our storage array
      98          286765 :     NS_ENSURE_TRUE(mData.InsertObjectAt(variant, i), NS_ERROR_OUT_OF_MEMORY);
      99                 : 
     100                 :     // Associate the name (if any) with the index
     101          286765 :     const char *name = ::sqlite3_column_name(aStatement, i);
     102          286765 :     if (!name) break;
     103          573530 :     nsCAutoString colName(name);
     104          286765 :     mNameHashtable.Put(colName, i);
     105                 :   }
     106                 : 
     107           24433 :   return NS_OK;
     108                 : }
     109                 : 
     110                 : /**
     111                 :  * Note:  This object is only ever accessed on one thread at a time.  It it not
     112                 :  *        threadsafe, but it does need threadsafe AddRef and Release.
     113                 :  */
     114          342021 : NS_IMPL_THREADSAFE_ISUPPORTS2(
     115                 :   Row,
     116                 :   mozIStorageRow,
     117                 :   mozIStorageValueArray
     118                 : )
     119                 : 
     120                 : ////////////////////////////////////////////////////////////////////////////////
     121                 : //// mozIStorageRow
     122                 : 
     123                 : NS_IMETHODIMP
     124          112188 : Row::GetResultByIndex(PRUint32 aIndex,
     125                 :                       nsIVariant **_result)
     126                 : {
     127          112188 :   ENSURE_INDEX_VALUE(aIndex, mNumCols);
     128          112188 :   NS_ADDREF(*_result = mData.ObjectAt(aIndex));
     129          112188 :   return NS_OK;
     130                 : }
     131                 : 
     132                 : NS_IMETHODIMP
     133          106807 : Row::GetResultByName(const nsACString &aName,
     134                 :                      nsIVariant **_result)
     135                 : {
     136                 :   PRUint32 index;
     137          106807 :   NS_ENSURE_TRUE(mNameHashtable.Get(aName, &index), NS_ERROR_NOT_AVAILABLE);
     138          106807 :   return GetResultByIndex(index, _result);
     139                 : }
     140                 : 
     141                 : ////////////////////////////////////////////////////////////////////////////////
     142                 : //// mozIStorageValueArray
     143                 : 
     144                 : NS_IMETHODIMP
     145              16 : Row::GetNumEntries(PRUint32 *_entries)
     146                 : {
     147              16 :   *_entries = mNumCols;
     148              16 :   return NS_OK;
     149                 : }
     150                 : 
     151                 : NS_IMETHODIMP
     152              12 : Row::GetTypeOfIndex(PRUint32 aIndex,
     153                 :                     PRInt32 *_type)
     154                 : {
     155              12 :   ENSURE_INDEX_VALUE(aIndex, mNumCols);
     156                 : 
     157                 :   PRUint16 type;
     158              10 :   (void)mData.ObjectAt(aIndex)->GetDataType(&type);
     159              10 :   switch (type) {
     160                 :     case nsIDataType::VTYPE_INT32:
     161                 :     case nsIDataType::VTYPE_INT64:
     162               2 :       *_type = mozIStorageValueArray::VALUE_TYPE_INTEGER;
     163               2 :       break;
     164                 :     case nsIDataType::VTYPE_DOUBLE:
     165               2 :       *_type = mozIStorageValueArray::VALUE_TYPE_FLOAT;
     166               2 :       break;
     167                 :     case nsIDataType::VTYPE_ASTRING:
     168               2 :       *_type = mozIStorageValueArray::VALUE_TYPE_TEXT;
     169               2 :       break;
     170                 :     case nsIDataType::VTYPE_ARRAY:
     171               2 :       *_type = mozIStorageValueArray::VALUE_TYPE_BLOB;
     172               2 :       break;
     173                 :     default:
     174               2 :       *_type = mozIStorageValueArray::VALUE_TYPE_NULL;
     175               2 :       break;
     176                 :   }
     177              10 :   return NS_OK;
     178                 : }
     179                 : 
     180                 : NS_IMETHODIMP
     181           22652 : Row::GetInt32(PRUint32 aIndex,
     182                 :               PRInt32 *_value)
     183                 : {
     184           22652 :   ENSURE_INDEX_VALUE(aIndex, mNumCols);
     185           22650 :   return mData.ObjectAt(aIndex)->GetAsInt32(_value);
     186                 : }
     187                 : 
     188                 : NS_IMETHODIMP
     189           34418 : Row::GetInt64(PRUint32 aIndex,
     190                 :               PRInt64 *_value)
     191                 : {
     192           34418 :   ENSURE_INDEX_VALUE(aIndex, mNumCols);
     193           34416 :   return mData.ObjectAt(aIndex)->GetAsInt64(_value);
     194                 : }
     195                 : 
     196                 : NS_IMETHODIMP
     197               2 : Row::GetDouble(PRUint32 aIndex,
     198                 :                double *_value)
     199                 : {
     200               2 :   ENSURE_INDEX_VALUE(aIndex, mNumCols);
     201               0 :   return mData.ObjectAt(aIndex)->GetAsDouble(_value);
     202                 : }
     203                 : 
     204                 : NS_IMETHODIMP
     205           56888 : Row::GetUTF8String(PRUint32 aIndex,
     206                 :                    nsACString &_value)
     207                 : {
     208           56888 :   ENSURE_INDEX_VALUE(aIndex, mNumCols);
     209           56886 :   return mData.ObjectAt(aIndex)->GetAsAUTF8String(_value);
     210                 : }
     211                 : 
     212                 : NS_IMETHODIMP
     213               4 : Row::GetString(PRUint32 aIndex,
     214                 :                nsAString &_value)
     215                 : {
     216               4 :   ENSURE_INDEX_VALUE(aIndex, mNumCols);
     217               2 :   return mData.ObjectAt(aIndex)->GetAsAString(_value);
     218                 : }
     219                 : 
     220                 : NS_IMETHODIMP
     221               5 : Row::GetBlob(PRUint32 aIndex,
     222                 :              PRUint32 *_size,
     223                 :              PRUint8 **_blob)
     224                 : {
     225               5 :   ENSURE_INDEX_VALUE(aIndex, mNumCols);
     226                 : 
     227                 :   PRUint16 type;
     228                 :   nsIID interfaceIID;
     229               3 :   return mData.ObjectAt(aIndex)->GetAsArray(&type, &interfaceIID, _size,
     230               3 :                                             reinterpret_cast<void **>(_blob));
     231                 : }
     232                 : 
     233                 : NS_IMETHODIMP
     234              36 : Row::GetIsNull(PRUint32 aIndex,
     235                 :                bool *_isNull)
     236                 : {
     237              36 :   ENSURE_INDEX_VALUE(aIndex, mNumCols);
     238              34 :   NS_ENSURE_ARG_POINTER(_isNull);
     239                 : 
     240                 :   PRUint16 type;
     241              34 :   (void)mData.ObjectAt(aIndex)->GetDataType(&type);
     242              34 :   *_isNull = type == nsIDataType::VTYPE_EMPTY;
     243              34 :   return NS_OK;
     244                 : }
     245                 : 
     246                 : NS_IMETHODIMP
     247               0 : Row::GetSharedUTF8String(PRUint32,
     248                 :                          PRUint32 *,
     249                 :                          char const **)
     250                 : {
     251               0 :   return NS_ERROR_NOT_IMPLEMENTED;
     252                 : }
     253                 : 
     254                 : NS_IMETHODIMP
     255               0 : Row::GetSharedString(PRUint32,
     256                 :                      PRUint32 *,
     257                 :                      const PRUnichar **)
     258                 : {
     259               0 :   return NS_ERROR_NOT_IMPLEMENTED;
     260                 : }
     261                 : 
     262                 : NS_IMETHODIMP
     263               0 : Row::GetSharedBlob(PRUint32,
     264                 :                    PRUint32 *,
     265                 :                    const PRUint8 **)
     266                 : {
     267               0 :   return NS_ERROR_NOT_IMPLEMENTED;
     268                 : }
     269                 : 
     270                 : } // namespace storage
     271                 : } // namespace mozilla

Generated by: LCOV version 1.7