storage/mozStorageBindingParams.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 <limits.h>
   8
   9 #include "mozilla/UniquePtrExtensions.h"
  10 #include "nsString.h"
  11
  12 #include "mozStorageError.h"
  13 #include "mozStoragePrivateHelpers.h"
  14 #include "mozStorageBindingParams.h"
  15 #include "mozStorageBindingParamsArray.h"
  16 #include "Variant.h"
  17
  18 namespace mozilla {
  19 namespace storage {
  20
  21 ////////////////////////////////////////////////////////////////////////////////
  22 //// Local Helper Objects
  23
  24 namespace {
  25
  26 struct BindingColumnData {
  27   BindingColumnData(sqlite3_stmt* aStmt, int aColumn)
  28       : stmt(aStmt), column(aColumn) {}
  29   sqlite3_stmt* stmt;
  30   int column;
  31 };
  32
  33 ////////////////////////////////////////////////////////////////////////////////
  34 //// Variant Specialization Functions (variantToSQLiteT)
  35
  36 int sqlite3_T_int(BindingColumnData aData, int aValue) {
  37   return ::sqlite3_bind_int(aData.stmt, aData.column + 1, aValue);
  38 }
  39
  40 int sqlite3_T_int64(BindingColumnData aData, sqlite3_int64 aValue) {
  41   return ::sqlite3_bind_int64(aData.stmt, aData.column + 1, aValue);
  42 }
  43
  44 int sqlite3_T_double(BindingColumnData aData, double aValue) {
  45   return ::sqlite3_bind_double(aData.stmt, aData.column + 1, aValue);
  46 }
  47
  48 int sqlite3_T_text(BindingColumnData aData, const nsCString& aValue) {
  49   return ::sqlite3_bind_text(aData.stmt, aData.column + 1, aValue.get(),
  50                              aValue.Length(), SQLITE_TRANSIENT);
  51 }
  52
  53 int sqlite3_T_text16(BindingColumnData aData, const nsString& aValue) {
  54   return ::sqlite3_bind_text16(
  55       aData.stmt, aData.column + 1, aValue.get(),
  56       aValue.Length() * sizeof(char16_t),  // Length in bytes!
  57       SQLITE_TRANSIENT);
  58 }
  59
  60 int sqlite3_T_null(BindingColumnData aData) {
  61   return ::sqlite3_bind_null(aData.stmt, aData.column + 1);
  62 }
  63
  64 int sqlite3_T_blob(BindingColumnData aData, const void* aBlob, int aSize) {
  65   return ::sqlite3_bind_blob(aData.stmt, aData.column + 1, aBlob, aSize, free);
  66 }
  67
  68 #include "variantToSQLiteT_impl.h"
  69
  70 }  // namespace
  71
  72 ////////////////////////////////////////////////////////////////////////////////
  73 //// BindingParams
  74
  75 BindingParams::BindingParams(mozIStorageBindingParamsArray* aOwningArray,
  76                              Statement* aOwningStatement)
  77     : mLocked(false),
  78       mOwningArray(aOwningArray),
  79       mOwningStatement(aOwningStatement),
  80       mParamCount(0) {
  81   (void)mOwningStatement->GetParameterCount(&mParamCount);
  82   mParameters.SetCapacity(mParamCount);
  83 }
  84
  85 BindingParams::BindingParams(mozIStorageBindingParamsArray* aOwningArray)
  86     : mLocked(false),
  87       mOwningArray(aOwningArray),
  88       mOwningStatement(nullptr),
  89       mParamCount(0) {}
  90
  91 AsyncBindingParams::AsyncBindingParams(
  92     mozIStorageBindingParamsArray* aOwningArray)
  93     : BindingParams(aOwningArray) {}
  94
  95 void BindingParams::lock() {
  96   NS_ASSERTION(mLocked == false, "Parameters have already been locked!");
  97   mLocked = true;
  98
  99   // We no longer need to hold a reference to our statement or our owning array.
 100   // The array owns us at this point, and it will own a reference to the
 101   // statement.
 102   mOwningStatement = nullptr;
 103   mOwningArray = nullptr;
 104 }
 105
 106 void BindingParams::unlock(Statement* aOwningStatement) {
 107   NS_ASSERTION(mLocked == true, "Parameters were not yet locked!");
 108   mLocked = false;
 109   mOwningStatement = aOwningStatement;
 110 }
 111
 112 const mozIStorageBindingParamsArray* BindingParams::getOwner() const {
 113   return mOwningArray;
 114 }
 115
 116 ////////////////////////////////////////////////////////////////////////////////
 117 //// nsISupports
 118
 119 NS_IMPL_ISUPPORTS(BindingParams, mozIStorageBindingParams,
 120                   IStorageBindingParamsInternal)
 121
 122 ////////////////////////////////////////////////////////////////////////////////
 123 //// IStorageBindingParamsInternal
 124
 125 already_AddRefed<mozIStorageError> BindingParams::bind(
 126     sqlite3_stmt* aStatement) {
 127   // Iterate through all of our stored data, and bind it.
 128   for (size_t i = 0; i < mParameters.Length(); i++) {
 129     int rc = variantToSQLiteT(BindingColumnData(aStatement, i), mParameters[i]);
 130     if (rc != SQLITE_OK) {
 131       // We had an error while trying to bind.  Now we need to create an error
 132       // object with the right message.  Note that we special case
 133       // SQLITE_MISMATCH, but otherwise get the message from SQLite.
 134       const char* msg = "Could not covert nsIVariant to SQLite type.";
 135       if (rc != SQLITE_MISMATCH)
 136         msg = ::sqlite3_errmsg(::sqlite3_db_handle(aStatement));
 137
 138       nsCOMPtr<mozIStorageError> err(new Error(rc, msg));
 139       return err.forget();
 140     }
 141   }
 142
 143   return nullptr;
 144 }
 145
 146 already_AddRefed<mozIStorageError> AsyncBindingParams::bind(
 147     sqlite3_stmt* aStatement) {
 148   // We should bind by index using the super-class if there is nothing in our
 149   // hashtable.
 150   if (!mNamedParameters.Count()) return BindingParams::bind(aStatement);
 151
 152   nsCOMPtr<mozIStorageError> err;
 153
 154   for (auto iter = mNamedParameters.Iter(); !iter.Done(); iter.Next()) {
 155     const nsACString& key = iter.Key();
 156
 157     // We do not accept any forms of names other than ":name", but we need to
 158     // add the colon for SQLite.
 159     nsAutoCString name(":");
 160     name.Append(key);
 161     int oneIdx = ::sqlite3_bind_parameter_index(aStatement, name.get());
 162
 163     if (oneIdx == 0) {
 164       nsAutoCString errMsg(key);
 165       errMsg.AppendLiteral(" is not a valid named parameter.");
 166       err = new Error(SQLITE_RANGE, errMsg.get());
 167       break;
 168     }
 169
 170     // XPCVariant's AddRef and Release are not thread-safe and so we must not
 171     // do anything that would invoke them here on the async thread.  As such we
 172     // can't cram aValue into mParameters using ReplaceObjectAt so that
 173     // we can freeload off of the BindingParams::Bind implementation.
 174     int rc = variantToSQLiteT(BindingColumnData(aStatement, oneIdx - 1),
 175                               iter.UserData());
 176     if (rc != SQLITE_OK) {
 177       // We had an error while trying to bind.  Now we need to create an error
 178       // object with the right message.  Note that we special case
 179       // SQLITE_MISMATCH, but otherwise get the message from SQLite.
 180       const char* msg = "Could not covert nsIVariant to SQLite type.";
 181       if (rc != SQLITE_MISMATCH) {
 182         msg = ::sqlite3_errmsg(::sqlite3_db_handle(aStatement));
 183       }
 184       err = new Error(rc, msg);
 185       break;
 186     }
 187   }
 188
 189   return err.forget();
 190 }
 191
 192 ///////////////////////////////////////////////////////////////////////////////
 193 //// mozIStorageBindingParams
 194
 195 NS_IMETHODIMP
 196 BindingParams::BindByName(const nsACString& aName, nsIVariant* aValue) {
 197   NS_ENSURE_FALSE(mLocked, NS_ERROR_UNEXPECTED);
 198
 199   // Get the column index that we need to store this at.
 200   uint32_t index;
 201   nsresult rv = mOwningStatement->GetParameterIndex(aName, &index);
 202   NS_ENSURE_SUCCESS(rv, rv);
 203
 204   return BindByIndex(index, aValue);
 205 }
 206
 207 NS_IMETHODIMP
 208 AsyncBindingParams::BindByName(const nsACString& aName, nsIVariant* aValue) {
 209   NS_ENSURE_FALSE(mLocked, NS_ERROR_UNEXPECTED);
 210
 211   RefPtr<Variant_base> variant = convertVariantToStorageVariant(aValue);
 212   if (!variant) return NS_ERROR_UNEXPECTED;
 213
 214   mNamedParameters.Put(aName, variant);
 215   return NS_OK;
 216 }
 217
 218 NS_IMETHODIMP
 219 BindingParams::BindUTF8StringByName(const nsACString& aName,
 220                                     const nsACString& aValue) {
 221   nsCOMPtr<nsIVariant> value(new UTF8TextVariant(aValue));
 222   NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
 223
 224   return BindByName(aName, value);
 225 }
 226
 227 NS_IMETHODIMP
 228 BindingParams::BindStringByName(const nsACString& aName,
 229                                 const nsAString& aValue) {
 230   nsCOMPtr<nsIVariant> value(new TextVariant(aValue));
 231   NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
 232
 233   return BindByName(aName, value);
 234 }
 235
 236 NS_IMETHODIMP
 237 BindingParams::BindDoubleByName(const nsACString& aName, double aValue) {
 238   nsCOMPtr<nsIVariant> value(new FloatVariant(aValue));
 239   NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
 240
 241   return BindByName(aName, value);
 242 }
 243
 244 NS_IMETHODIMP
 245 BindingParams::BindInt32ByName(const nsACString& aName, int32_t aValue) {
 246   nsCOMPtr<nsIVariant> value(new IntegerVariant(aValue));
 247   NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
 248
 249   return BindByName(aName, value);
 250 }
 251
 252 NS_IMETHODIMP
 253 BindingParams::BindInt64ByName(const nsACString& aName, int64_t aValue) {
 254   nsCOMPtr<nsIVariant> value(new IntegerVariant(aValue));
 255   NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
 256
 257   return BindByName(aName, value);
 258 }
 259
 260 NS_IMETHODIMP
 261 BindingParams::BindNullByName(const nsACString& aName) {
 262   nsCOMPtr<nsIVariant> value(new NullVariant());
 263   NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
 264
 265   return BindByName(aName, value);
 266 }
 267
 268 NS_IMETHODIMP
 269 BindingParams::BindBlobByName(const nsACString& aName, const uint8_t* aValue,
 270                               uint32_t aValueSize) {
 271   NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);
 272   std::pair<const void*, int> data(static_cast<const void*>(aValue),
 273                                    int(aValueSize));
 274   nsCOMPtr<nsIVariant> value(new BlobVariant(data));
 275   NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
 276
 277   return BindByName(aName, value);
 278 }
 279
 280 NS_IMETHODIMP
 281 BindingParams::BindBlobArrayByName(const nsACString& aName,
 282                                    const nsTArray<uint8_t>& aValue) {
 283   return BindBlobByName(aName, aValue.Elements(), aValue.Length());
 284 }
 285
 286 NS_IMETHODIMP
 287 BindingParams::BindStringAsBlobByName(const nsACString& aName,
 288                                       const nsAString& aValue) {
 289   return DoBindStringAsBlobByName(this, aName, aValue);
 290 }
 291
 292 NS_IMETHODIMP
 293 BindingParams::BindUTF8StringAsBlobByName(const nsACString& aName,
 294                                           const nsACString& aValue) {
 295   return DoBindStringAsBlobByName(this, aName, aValue);
 296 }
 297
 298 NS_IMETHODIMP
 299 BindingParams::BindAdoptedBlobByName(const nsACString& aName, uint8_t* aValue,
 300                                      uint32_t aValueSize) {
 301   UniqueFreePtr<uint8_t> uniqueValue(aValue);
 302   NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);
 303   std::pair<uint8_t*, int> data(uniqueValue.release(), int(aValueSize));
 304   nsCOMPtr<nsIVariant> value(new AdoptedBlobVariant(data));
 305
 306   return BindByName(aName, value);
 307 }
 308
 309 NS_IMETHODIMP
 310 BindingParams::BindByIndex(uint32_t aIndex, nsIVariant* aValue) {
 311   NS_ENSURE_FALSE(mLocked, NS_ERROR_UNEXPECTED);
 312   ENSURE_INDEX_VALUE(aIndex, mParamCount);
 313
 314   // Store the variant for later use.
 315   RefPtr<Variant_base> variant = convertVariantToStorageVariant(aValue);
 316   if (!variant) return NS_ERROR_UNEXPECTED;
 317   if (mParameters.Length() <= aIndex) {
 318     (void)mParameters.SetLength(aIndex);
 319     (void)mParameters.AppendElement(variant);
 320   } else {
 321     NS_ENSURE_TRUE(mParameters.ReplaceElementAt(aIndex, variant),
 322                    NS_ERROR_OUT_OF_MEMORY);
 323   }
 324   return NS_OK;
 325 }
 326
 327 NS_IMETHODIMP
 328 AsyncBindingParams::BindByIndex(uint32_t aIndex, nsIVariant* aValue) {
 329   NS_ENSURE_FALSE(mLocked, NS_ERROR_UNEXPECTED);
 330   // In the asynchronous case we do not know how many parameters there are to
 331   // bind to, so we cannot check the validity of aIndex.
 332
 333   RefPtr<Variant_base> variant = convertVariantToStorageVariant(aValue);
 334   if (!variant) return NS_ERROR_UNEXPECTED;
 335   if (mParameters.Length() <= aIndex) {
 336     mParameters.SetLength(aIndex);
 337     mParameters.AppendElement(variant);
 338   } else {
 339     NS_ENSURE_TRUE(mParameters.ReplaceElementAt(aIndex, variant),
 340                    NS_ERROR_OUT_OF_MEMORY);
 341   }
 342   return NS_OK;
 343 }
 344
 345 NS_IMETHODIMP
 346 BindingParams::BindUTF8StringByIndex(uint32_t aIndex,
 347                                      const nsACString& aValue) {
 348   nsCOMPtr<nsIVariant> value(new UTF8TextVariant(aValue));
 349   NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
 350
 351   return BindByIndex(aIndex, value);
 352 }
 353
 354 NS_IMETHODIMP
 355 BindingParams::BindStringByIndex(uint32_t aIndex, const nsAString& aValue) {
 356   nsCOMPtr<nsIVariant> value(new TextVariant(aValue));
 357   NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
 358
 359   return BindByIndex(aIndex, value);
 360 }
 361
 362 NS_IMETHODIMP
 363 BindingParams::BindDoubleByIndex(uint32_t aIndex, double aValue) {
 364   nsCOMPtr<nsIVariant> value(new FloatVariant(aValue));
 365   NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
 366
 367   return BindByIndex(aIndex, value);
 368 }
 369
 370 NS_IMETHODIMP
 371 BindingParams::BindInt32ByIndex(uint32_t aIndex, int32_t aValue) {
 372   nsCOMPtr<nsIVariant> value(new IntegerVariant(aValue));
 373   NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
 374
 375   return BindByIndex(aIndex, value);
 376 }
 377
 378 NS_IMETHODIMP
 379 BindingParams::BindInt64ByIndex(uint32_t aIndex, int64_t aValue) {
 380   nsCOMPtr<nsIVariant> value(new IntegerVariant(aValue));
 381   NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
 382
 383   return BindByIndex(aIndex, value);
 384 }
 385
 386 NS_IMETHODIMP
 387 BindingParams::BindNullByIndex(uint32_t aIndex) {
 388   nsCOMPtr<nsIVariant> value(new NullVariant());
 389   NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
 390
 391   return BindByIndex(aIndex, value);
 392 }
 393
 394 NS_IMETHODIMP
 395 BindingParams::BindBlobByIndex(uint32_t aIndex, const uint8_t* aValue,
 396                                uint32_t aValueSize) {
 397   NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);
 398   std::pair<const void*, int> data(static_cast<const void*>(aValue),
 399                                    int(aValueSize));
 400   nsCOMPtr<nsIVariant> value(new BlobVariant(data));
 401   NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
 402
 403   return BindByIndex(aIndex, value);
 404 }
 405
 406 NS_IMETHODIMP
 407 BindingParams::BindBlobArrayByIndex(uint32_t aIndex,
 408                                     const nsTArray<uint8_t>& aValue) {
 409   return BindBlobByIndex(aIndex, aValue.Elements(), aValue.Length());
 410 }
 411
 412 NS_IMETHODIMP
 413 BindingParams::BindStringAsBlobByIndex(uint32_t aIndex,
 414                                        const nsAString& aValue) {
 415   return DoBindStringAsBlobByIndex(this, aIndex, aValue);
 416 }
 417
 418 NS_IMETHODIMP
 419 BindingParams::BindUTF8StringAsBlobByIndex(uint32_t aIndex,
 420                                            const nsACString& aValue) {
 421   return DoBindStringAsBlobByIndex(this, aIndex, aValue);
 422 }
 423
 424 NS_IMETHODIMP
 425 BindingParams::BindAdoptedBlobByIndex(uint32_t aIndex, uint8_t* aValue,
 426                                       uint32_t aValueSize) {
 427   UniqueFreePtr<uint8_t> uniqueValue(aValue);
 428   NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);
 429   std::pair<uint8_t*, int> data(uniqueValue.release(), int(aValueSize));
 430   nsCOMPtr<nsIVariant> value(new AdoptedBlobVariant(data));
 431
 432   return BindByIndex(aIndex, value);
 433 }
 434
 435 }  // namespace storage
 436 }  // namespace mozilla