storage/src/mozStorageRow.cpp

   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  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsString.h"
   8
   9 #include "sqlite3.h"
  10 #include "mozStoragePrivateHelpers.h"
  11 #include "Variant.h"
  12 #include "mozStorageRow.h"
  13
  14 namespace mozilla {
  15 namespace storage {
  16
  17 ////////////////////////////////////////////////////////////////////////////////
  18 //// Row
  19
  20 nsresult
  21 Row::initialize(sqlite3_stmt *aStatement)
  22 {
  23   // Initialize the hash table
  24   mNameHashtable.Init();
  25
  26   // Get the number of results
  27   mNumCols = ::sqlite3_column_count(aStatement);
  28
  29   // Start copying over values
  30   for (uint32_t i = 0; i < mNumCols; i++) {
  31     // Store the value
  32     nsIVariant *variant = nullptr;
  33     int type = ::sqlite3_column_type(aStatement, i);
  34     switch (type) {
  35       case SQLITE_INTEGER:
  36         variant = new IntegerVariant(::sqlite3_column_int64(aStatement, i));
  37         break;
  38       case SQLITE_FLOAT:
  39         variant = new FloatVariant(::sqlite3_column_double(aStatement, i));
  40         break;
  41       case SQLITE_TEXT:
  42       {
  43         nsDependentString str(
  44           static_cast<const PRUnichar *>(::sqlite3_column_text16(aStatement, i))
  45         );
  46         variant = new TextVariant(str);
  47         break;
  48       }
  49       case SQLITE_NULL:
  50         variant = new NullVariant();
  51         break;
  52       case SQLITE_BLOB:
  53       {
  54         int size = ::sqlite3_column_bytes(aStatement, i);
  55         const void *data = ::sqlite3_column_blob(aStatement, i);
  56         variant = new BlobVariant(std::pair<const void *, int>(data, size));
  57         break;
  58       }
  59       default:
  60         return NS_ERROR_UNEXPECTED;
  61     }
  62     NS_ENSURE_TRUE(variant, NS_ERROR_OUT_OF_MEMORY);
  63
  64     // Insert into our storage array
  65     NS_ENSURE_TRUE(mData.InsertObjectAt(variant, i), NS_ERROR_OUT_OF_MEMORY);
  66
  67     // Associate the name (if any) with the index
  68     const char *name = ::sqlite3_column_name(aStatement, i);
  69     if (!name) break;
  70     nsAutoCString colName(name);
  71     mNameHashtable.Put(colName, i);
  72   }
  73
  74   return NS_OK;
  75 }
  76
  77 /**
  78  * Note:  This object is only ever accessed on one thread at a time.  It it not
  79  *        threadsafe, but it does need threadsafe AddRef and Release.
  80  */
  81 NS_IMPL_THREADSAFE_ISUPPORTS2(
  82   Row,
  83   mozIStorageRow,
  84   mozIStorageValueArray
  85 )
  86
  87 ////////////////////////////////////////////////////////////////////////////////
  88 //// mozIStorageRow
  89
  90 NS_IMETHODIMP
  91 Row::GetResultByIndex(uint32_t aIndex,
  92                       nsIVariant **_result)
  93 {
  94   ENSURE_INDEX_VALUE(aIndex, mNumCols);
  95   NS_ADDREF(*_result = mData.ObjectAt(aIndex));
  96   return NS_OK;
  97 }
  98
  99 NS_IMETHODIMP
 100 Row::GetResultByName(const nsACString &aName,
 101                      nsIVariant **_result)
 102 {
 103   uint32_t index;
 104   NS_ENSURE_TRUE(mNameHashtable.Get(aName, &index), NS_ERROR_NOT_AVAILABLE);
 105   return GetResultByIndex(index, _result);
 106 }
 107
 108 ////////////////////////////////////////////////////////////////////////////////
 109 //// mozIStorageValueArray
 110
 111 NS_IMETHODIMP
 112 Row::GetNumEntries(uint32_t *_entries)
 113 {
 114   *_entries = mNumCols;
 115   return NS_OK;
 116 }
 117
 118 NS_IMETHODIMP
 119 Row::GetTypeOfIndex(uint32_t aIndex,
 120                     int32_t *_type)
 121 {
 122   ENSURE_INDEX_VALUE(aIndex, mNumCols);
 123
 124   uint16_t type;
 125   (void)mData.ObjectAt(aIndex)->GetDataType(&type);
 126   switch (type) {
 127     case nsIDataType::VTYPE_INT32:
 128     case nsIDataType::VTYPE_INT64:
 129       *_type = mozIStorageValueArray::VALUE_TYPE_INTEGER;
 130       break;
 131     case nsIDataType::VTYPE_DOUBLE:
 132       *_type = mozIStorageValueArray::VALUE_TYPE_FLOAT;
 133       break;
 134     case nsIDataType::VTYPE_ASTRING:
 135       *_type = mozIStorageValueArray::VALUE_TYPE_TEXT;
 136       break;
 137     case nsIDataType::VTYPE_ARRAY:
 138       *_type = mozIStorageValueArray::VALUE_TYPE_BLOB;
 139       break;
 140     default:
 141       *_type = mozIStorageValueArray::VALUE_TYPE_NULL;
 142       break;
 143   }
 144   return NS_OK;
 145 }
 146
 147 NS_IMETHODIMP
 148 Row::GetInt32(uint32_t aIndex,
 149               int32_t *_value)
 150 {
 151   ENSURE_INDEX_VALUE(aIndex, mNumCols);
 152   return mData.ObjectAt(aIndex)->GetAsInt32(_value);
 153 }
 154
 155 NS_IMETHODIMP
 156 Row::GetInt64(uint32_t aIndex,
 157               int64_t *_value)
 158 {
 159   ENSURE_INDEX_VALUE(aIndex, mNumCols);
 160   return mData.ObjectAt(aIndex)->GetAsInt64(_value);
 161 }
 162
 163 NS_IMETHODIMP
 164 Row::GetDouble(uint32_t aIndex,
 165                double *_value)
 166 {
 167   ENSURE_INDEX_VALUE(aIndex, mNumCols);
 168   return mData.ObjectAt(aIndex)->GetAsDouble(_value);
 169 }
 170
 171 NS_IMETHODIMP
 172 Row::GetUTF8String(uint32_t aIndex,
 173                    nsACString &_value)
 174 {
 175   ENSURE_INDEX_VALUE(aIndex, mNumCols);
 176   return mData.ObjectAt(aIndex)->GetAsAUTF8String(_value);
 177 }
 178
 179 NS_IMETHODIMP
 180 Row::GetString(uint32_t aIndex,
 181                nsAString &_value)
 182 {
 183   ENSURE_INDEX_VALUE(aIndex, mNumCols);
 184   return mData.ObjectAt(aIndex)->GetAsAString(_value);
 185 }
 186
 187 NS_IMETHODIMP
 188 Row::GetBlob(uint32_t aIndex,
 189              uint32_t *_size,
 190              uint8_t **_blob)
 191 {
 192   ENSURE_INDEX_VALUE(aIndex, mNumCols);
 193
 194   uint16_t type;
 195   nsIID interfaceIID;
 196   return mData.ObjectAt(aIndex)->GetAsArray(&type, &interfaceIID, _size,
 197                                             reinterpret_cast<void **>(_blob));
 198 }
 199
 200 NS_IMETHODIMP
 201 Row::GetIsNull(uint32_t aIndex,
 202                bool *_isNull)
 203 {
 204   ENSURE_INDEX_VALUE(aIndex, mNumCols);
 205   NS_ENSURE_ARG_POINTER(_isNull);
 206
 207   uint16_t type;
 208   (void)mData.ObjectAt(aIndex)->GetDataType(&type);
 209   *_isNull = type == nsIDataType::VTYPE_EMPTY;
 210   return NS_OK;
 211 }
 212
 213 NS_IMETHODIMP
 214 Row::GetSharedUTF8String(uint32_t,
 215                          uint32_t *,
 216                          char const **)
 217 {
 218   return NS_ERROR_NOT_IMPLEMENTED;
 219 }
 220
 221 NS_IMETHODIMP
 222 Row::GetSharedString(uint32_t,
 223                      uint32_t *,
 224                      const PRUnichar **)
 225 {
 226   return NS_ERROR_NOT_IMPLEMENTED;
 227 }
 228
 229 NS_IMETHODIMP
 230 Row::GetSharedBlob(uint32_t,
 231                    uint32_t *,
 232                    const uint8_t **)
 233 {
 234   return NS_ERROR_NOT_IMPLEMENTED;
 235 }
 236
 237 } // namespace storage
 238 } // namespace mozilla