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