[ tor-browser ].git.dasho

mozStorageStatement.cpp (25979B)
      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 #include <stdio.h>
      9 
     10 #include "nsError.h"
     11 #include "nsThreadUtils.h"
     12 #include "nsIClassInfoImpl.h"
     13 #include "Variant.h"
     14 
     15 #include "mozIStorageError.h"
     16 
     17 #include "mozStorageBindingParams.h"
     18 #include "mozStorageConnection.h"
     19 #include "mozStorageStatementJSHelper.h"
     20 #include "mozStoragePrivateHelpers.h"
     21 #include "mozStorageStatementParams.h"
     22 #include "mozStorageStatementRow.h"
     23 #include "mozStorageStatement.h"
     24 
     25 #include "mozilla/Logging.h"
     26 #include "mozilla/Printf.h"
     27 #include "mozilla/ProfilerLabels.h"
     28 
     29 extern mozilla::LazyLogModule gStorageLog;
     30 
     31 namespace mozilla {
     32 namespace storage {
     33 
     34 ////////////////////////////////////////////////////////////////////////////////
     35 //// nsIClassInfo
     36 
     37 NS_IMPL_CI_INTERFACE_GETTER(Statement, mozIStorageStatement,
     38                            mozIStorageBaseStatement, mozIStorageBindingParams,
     39                            mozIStorageValueArray,
     40                            mozilla::storage::StorageBaseStatementInternal)
     41 
     42 class StatementClassInfo : public nsIClassInfo {
     43 public:
     44  constexpr StatementClassInfo() = default;
     45 
     46  NS_DECL_ISUPPORTS_INHERITED
     47 
     48  NS_IMETHOD
     49  GetInterfaces(nsTArray<nsIID>& _array) override {
     50    return NS_CI_INTERFACE_GETTER_NAME(Statement)(_array);
     51  }
     52 
     53  NS_IMETHOD
     54  GetScriptableHelper(nsIXPCScriptable** _helper) override {
     55    static StatementJSHelper sJSHelper;
     56    *_helper = &sJSHelper;
     57    return NS_OK;
     58  }
     59 
     60  NS_IMETHOD
     61  GetContractID(nsACString& aContractID) override {
     62    aContractID.SetIsVoid(true);
     63    return NS_OK;
     64  }
     65 
     66  NS_IMETHOD
     67  GetClassDescription(nsACString& aDesc) override {
     68    aDesc.SetIsVoid(true);
     69    return NS_OK;
     70  }
     71 
     72  NS_IMETHOD
     73  GetClassID(nsCID** _id) override {
     74    *_id = nullptr;
     75    return NS_OK;
     76  }
     77 
     78  NS_IMETHOD
     79  GetFlags(uint32_t* _flags) override {
     80    *_flags = 0;
     81    return NS_OK;
     82  }
     83 
     84  NS_IMETHOD
     85  GetClassIDNoAlloc(nsCID* _cid) override { return NS_ERROR_NOT_AVAILABLE; }
     86 };
     87 
     88 NS_IMETHODIMP_(MozExternalRefCountType) StatementClassInfo::AddRef() {
     89  return 2;
     90 }
     91 NS_IMETHODIMP_(MozExternalRefCountType) StatementClassInfo::Release() {
     92  return 1;
     93 }
     94 NS_IMPL_QUERY_INTERFACE(StatementClassInfo, nsIClassInfo)
     95 
     96 static StatementClassInfo sStatementClassInfo;
     97 
     98 ////////////////////////////////////////////////////////////////////////////////
     99 //// Statement
    100 
    101 Statement::Statement()
    102    : mDBStatement(nullptr),
    103      mParamCount(0),
    104      mResultColumnCount(0),
    105      mExecuting(false),
    106      mQueryStatusRecorded(false),
    107      mHasExecuted(false) {}
    108 
    109 nsresult Statement::initialize(Connection* aDBConnection,
    110                               sqlite3* aNativeConnection,
    111                               const nsACString& aSQLStatement) {
    112  MOZ_ASSERT(aDBConnection, "No database connection given!");
    113  MOZ_ASSERT(aDBConnection->isConnectionReadyOnThisThread(),
    114             "Database connection should be valid");
    115  MOZ_ASSERT(!mDBStatement, "Statement already initialized!");
    116  MOZ_ASSERT(aNativeConnection, "No native connection given!");
    117 
    118  int srv = aDBConnection->prepareStatement(
    119      aNativeConnection, PromiseFlatCString(aSQLStatement), &mDBStatement);
    120  if (srv != SQLITE_OK) {
    121    MOZ_LOG(gStorageLog, LogLevel::Error,
    122            ("Sqlite statement prepare error: %d '%s'", srv,
    123             ::sqlite3_errmsg(aNativeConnection)));
    124    MOZ_LOG(gStorageLog, LogLevel::Error,
    125            ("Statement was: '%s'", PromiseFlatCString(aSQLStatement).get()));
    126 
    127    aDBConnection->RecordQueryStatus(srv);
    128    mQueryStatusRecorded = true;
    129    return convertResultCode(srv);
    130  }
    131 
    132  MOZ_LOG(gStorageLog, LogLevel::Debug,
    133          ("Initialized statement '%s' (0x%p)",
    134           PromiseFlatCString(aSQLStatement).get(), mDBStatement));
    135 
    136  mDBConnection = aDBConnection;
    137  mNativeConnection = aNativeConnection;
    138  mParamCount = ::sqlite3_bind_parameter_count(mDBStatement);
    139  mResultColumnCount = ::sqlite3_column_count(mDBStatement);
    140  mColumnNames.Clear();
    141 
    142  nsCString* columnNames = mColumnNames.AppendElements(mResultColumnCount);
    143  for (uint32_t i = 0; i < mResultColumnCount; i++) {
    144    const char* name = ::sqlite3_column_name(mDBStatement, i);
    145    columnNames[i].Assign(name);
    146  }
    147 
    148 #ifdef DEBUG
    149  // We want to try and test for LIKE and that consumers are using
    150  // escapeStringForLIKE instead of just trusting user input.  The idea to
    151  // check to see if they are binding a parameter after like instead of just
    152  // using a string.  We only do this in debug builds because it's expensive!
    153  auto c = nsCaseInsensitiveCStringComparator;
    154  nsACString::const_iterator start, end, e;
    155  aSQLStatement.BeginReading(start);
    156  aSQLStatement.EndReading(end);
    157  e = end;
    158  while (::FindInReadable(" LIKE"_ns, start, e, c)) {
    159    // We have a LIKE in here, so we perform our tests
    160    // FindInReadable moves the iterator, so we have to get a new one for
    161    // each test we perform.
    162    nsACString::const_iterator s1, s2, s3;
    163    s1 = s2 = s3 = start;
    164 
    165    if (!(::FindInReadable(" LIKE ?"_ns, s1, end, c) ||
    166          ::FindInReadable(" LIKE :"_ns, s2, end, c) ||
    167          ::FindInReadable(" LIKE @"_ns, s3, end, c))) {
    168      // At this point, we didn't find a LIKE statement followed by ?, :,
    169      // or @, all of which are valid characters for binding a parameter.
    170      // We will warn the consumer that they may not be safely using LIKE.
    171      NS_WARNING(
    172          "Unsafe use of LIKE detected!  Please ensure that you "
    173          "are using mozIStorageStatement::escapeStringForLIKE "
    174          "and that you are binding that result to the statement "
    175          "to prevent SQL injection attacks.");
    176    }
    177 
    178    // resetting start and e
    179    start = e;
    180    e = end;
    181  }
    182 #endif
    183 
    184  return NS_OK;
    185 }
    186 
    187 mozIStorageBindingParams* Statement::getParams() {
    188  nsresult rv;
    189 
    190  // If we do not have an array object yet, make it.
    191  if (!mParamsArray) {
    192    nsCOMPtr<mozIStorageBindingParamsArray> array;
    193    rv = NewBindingParamsArray(getter_AddRefs(array));
    194    NS_ENSURE_SUCCESS(rv, nullptr);
    195 
    196    mParamsArray = static_cast<BindingParamsArray*>(array.get());
    197  }
    198 
    199  // If there isn't already any rows added, we'll have to add one to use.
    200  if (mParamsArray->length() == 0) {
    201    RefPtr<BindingParams> params(new BindingParams(mParamsArray, this));
    202    NS_ENSURE_TRUE(params, nullptr);
    203 
    204    rv = mParamsArray->AddParams(params);
    205    NS_ENSURE_SUCCESS(rv, nullptr);
    206 
    207    // We have to unlock our params because AddParams locks them.  This is safe
    208    // because no reference to the params object was, or ever will be given out.
    209    params->unlock(this);
    210 
    211    // We also want to lock our array at this point - we don't want anything to
    212    // be added to it.  Nothing has, or will ever get a reference to it, but we
    213    // will get additional safety checks via assertions by doing this.
    214    mParamsArray->lock();
    215  }
    216 
    217  return *mParamsArray->begin();
    218 }
    219 
    220 void Statement::MaybeRecordQueryStatus(int srv, bool isResetting) {
    221  // If the statement hasn't been executed synchronously since it was last reset
    222  // or created then there is no need to record anything. Asynchronous
    223  // statements have their status tracked and recorded by StatementData.
    224  if (!mHasExecuted) {
    225    return;
    226  }
    227 
    228  if (!isResetting && !isErrorCode(srv)) {
    229    // Non-errors will be recorded when finalizing.
    230    return;
    231  }
    232 
    233  // We only record a status if no status has been recorded previously.
    234  if (!mQueryStatusRecorded && mDBConnection) {
    235    mDBConnection->RecordQueryStatus(srv);
    236  }
    237 
    238  // Allow another status to be recorded if we are resetting this statement.
    239  mQueryStatusRecorded = !isResetting;
    240 }
    241 
    242 Statement::~Statement() { (void)internalFinalize(true); }
    243 
    244 ////////////////////////////////////////////////////////////////////////////////
    245 //// nsISupports
    246 
    247 NS_IMPL_ADDREF(Statement)
    248 NS_IMPL_RELEASE(Statement)
    249 
    250 NS_INTERFACE_MAP_BEGIN(Statement)
    251  NS_INTERFACE_MAP_ENTRY(mozIStorageStatement)
    252  NS_INTERFACE_MAP_ENTRY(mozIStorageBaseStatement)
    253  NS_INTERFACE_MAP_ENTRY(mozIStorageBindingParams)
    254  NS_INTERFACE_MAP_ENTRY(mozIStorageValueArray)
    255  NS_INTERFACE_MAP_ENTRY(mozilla::storage::StorageBaseStatementInternal)
    256  if (aIID.Equals(NS_GET_IID(nsIClassInfo))) {
    257    foundInterface = static_cast<nsIClassInfo*>(&sStatementClassInfo);
    258  } else
    259    NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozIStorageStatement)
    260 NS_INTERFACE_MAP_END
    261 
    262 ////////////////////////////////////////////////////////////////////////////////
    263 //// StorageBaseStatementInternal
    264 
    265 Connection* Statement::getOwner() { return mDBConnection; }
    266 
    267 int Statement::getAsyncStatement(sqlite3_stmt** _stmt) {
    268  // If we have no statement, we shouldn't be calling this method!
    269  NS_ASSERTION(mDBStatement != nullptr, "We have no statement to clone!");
    270 
    271  // If we do not yet have a cached async statement, clone our statement now.
    272  if (!mAsyncStatement) {
    273    nsDependentCString sql(::sqlite3_sql(mDBStatement));
    274    int rc = mDBConnection->prepareStatement(mNativeConnection, sql,
    275                                             &mAsyncStatement);
    276    if (rc != SQLITE_OK) {
    277      mDBConnection->RecordQueryStatus(rc);
    278      *_stmt = nullptr;
    279      return rc;
    280    }
    281 
    282    MOZ_LOG(gStorageLog, LogLevel::Debug,
    283            ("Cloned statement 0x%p to 0x%p", mDBStatement, mAsyncStatement));
    284  }
    285 
    286  *_stmt = mAsyncStatement;
    287  return SQLITE_OK;
    288 }
    289 
    290 nsresult Statement::getAsynchronousStatementData(StatementData& _data) {
    291  if (!mDBStatement) return NS_ERROR_UNEXPECTED;
    292 
    293  sqlite3_stmt* stmt;
    294  int rc = getAsyncStatement(&stmt);
    295  if (rc != SQLITE_OK) return convertResultCode(rc);
    296 
    297  _data = StatementData(stmt, bindingParamsArray(), this);
    298 
    299  return NS_OK;
    300 }
    301 
    302 already_AddRefed<mozIStorageBindingParams> Statement::newBindingParams(
    303    mozIStorageBindingParamsArray* aOwner) {
    304  nsCOMPtr<mozIStorageBindingParams> params = new BindingParams(aOwner, this);
    305  return params.forget();
    306 }
    307 
    308 ////////////////////////////////////////////////////////////////////////////////
    309 //// mozIStorageStatement
    310 
    311 // proxy to StorageBaseStatementInternal using its define helper.
    312 MIXIN_IMPL_STORAGEBASESTATEMENTINTERNAL(Statement, (void)0;)
    313 
    314 NS_IMETHODIMP
    315 Statement::Clone(mozIStorageStatement** _statement) {
    316  RefPtr<Statement> statement(new Statement());
    317  NS_ENSURE_TRUE(statement, NS_ERROR_OUT_OF_MEMORY);
    318 
    319  nsAutoCString sql(::sqlite3_sql(mDBStatement));
    320  nsresult rv = statement->initialize(mDBConnection, mNativeConnection, sql);
    321  NS_ENSURE_SUCCESS(rv, rv);
    322 
    323  statement.forget(_statement);
    324  return NS_OK;
    325 }
    326 
    327 NS_IMETHODIMP
    328 Statement::Finalize() { return internalFinalize(false); }
    329 
    330 nsresult Statement::internalFinalize(bool aDestructing) {
    331  if (!mDBStatement) return NS_OK;
    332 
    333  int srv = SQLITE_OK;
    334 
    335  {
    336    // If the statement ends up being finalized twice, the second finalization
    337    // would apply to a dangling pointer and may cause unexpected consequences.
    338    // Thus we must be sure that the connection state won't change during this
    339    // operation, to avoid racing with finalizations made by the closing
    340    // connection.  See Connection::internalClose().
    341    MutexAutoLock lockedScope(mDBConnection->sharedAsyncExecutionMutex);
    342    if (!mDBConnection->isClosed(lockedScope)) {
    343      MOZ_LOG(gStorageLog, LogLevel::Debug,
    344              ("Finalizing statement '%s' during garbage-collection",
    345               ::sqlite3_sql(mDBStatement)));
    346      srv = ::sqlite3_finalize(mDBStatement);
    347    }
    348 #ifdef DEBUG
    349    else {
    350      // The database connection is closed. The sqlite
    351      // statement has either been finalized already by the connection
    352      // or is about to be finalized by the connection.
    353      //
    354      // Finalizing it here would be useless and segfaultish.
    355      //
    356      // Note that we can't display the statement itself, as the data structure
    357      // is not valid anymore. However, the address shown here should help
    358      // developers correlate with the more complete debug message triggered
    359      // by AsyncClose().
    360 
    361      SmprintfPointer msg = ::mozilla::Smprintf(
    362          "SQL statement (%p) should have been finalized"
    363          " before garbage-collection. For more details on this statement, set"
    364          " NSPR_LOG_MESSAGES=mozStorage:5 .",
    365          mDBStatement);
    366      NS_WARNING(msg.get());
    367 
    368      // Use %s so we aren't exposing random strings to printf interpolation.
    369      MOZ_LOG(gStorageLog, LogLevel::Warning, ("%s", msg.get()));
    370    }
    371 #endif  // DEBUG
    372  }
    373 
    374  // This will be a no-op if the status has already been recorded or if this
    375  // statement has not been executed. Async statements have their status
    376  // tracked and recorded in StatementData.
    377  MaybeRecordQueryStatus(srv, true);
    378 
    379  mDBStatement = nullptr;
    380 
    381  if (mAsyncStatement) {
    382    // If the destructor called us, there are no pending async statements (they
    383    // hold a reference to us) and we can/must just kill the statement directly.
    384    if (aDestructing)
    385      destructorAsyncFinalize();
    386    else
    387      asyncFinalize();
    388  }
    389 
    390  // Release the holders, so they can release the reference to us.
    391  mStatementParamsHolder = nullptr;
    392  mStatementRowHolder = nullptr;
    393 
    394  return convertResultCode(srv);
    395 }
    396 
    397 NS_IMETHODIMP
    398 Statement::GetParameterCount(uint32_t* _parameterCount) {
    399  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    400 
    401  *_parameterCount = mParamCount;
    402  return NS_OK;
    403 }
    404 
    405 NS_IMETHODIMP
    406 Statement::GetParameterName(uint32_t aParamIndex, nsACString& _name) {
    407  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    408  ENSURE_INDEX_VALUE(aParamIndex, mParamCount);
    409 
    410  const char* name =
    411      ::sqlite3_bind_parameter_name(mDBStatement, aParamIndex + 1);
    412  if (name == nullptr) {
    413    // this thing had no name, so fake one
    414    nsAutoCString fakeName(":");
    415    fakeName.AppendInt(aParamIndex);
    416    _name.Assign(fakeName);
    417  } else {
    418    _name.Assign(nsDependentCString(name));
    419  }
    420 
    421  return NS_OK;
    422 }
    423 
    424 NS_IMETHODIMP
    425 Statement::GetParameterIndex(const nsACString& aName, uint32_t* _index) {
    426  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    427 
    428  // We do not accept any forms of names other than ":name", but we need to add
    429  // the colon for SQLite.
    430  nsAutoCString name(":");
    431  name.Append(aName);
    432  int ind = ::sqlite3_bind_parameter_index(mDBStatement, name.get());
    433  if (ind == 0)  // Named parameter not found.
    434    return NS_ERROR_INVALID_ARG;
    435 
    436  *_index = ind - 1;  // SQLite indexes are 1-based, we are 0-based.
    437 
    438  return NS_OK;
    439 }
    440 
    441 NS_IMETHODIMP
    442 Statement::GetColumnCount(uint32_t* _columnCount) {
    443  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    444 
    445  *_columnCount = mResultColumnCount;
    446  return NS_OK;
    447 }
    448 
    449 NS_IMETHODIMP
    450 Statement::GetColumnName(uint32_t aColumnIndex, nsACString& _name) {
    451  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    452  ENSURE_INDEX_VALUE(aColumnIndex, mResultColumnCount);
    453 
    454  const char* cname = ::sqlite3_column_name(mDBStatement, aColumnIndex);
    455  _name.Assign(nsDependentCString(cname));
    456 
    457  return NS_OK;
    458 }
    459 
    460 NS_IMETHODIMP
    461 Statement::GetColumnIndex(const nsACString& aName, uint32_t* _index) {
    462  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    463 
    464  // Surprisingly enough, SQLite doesn't provide an API for this.  We have to
    465  // determine it ourselves sadly.
    466  for (uint32_t i = 0; i < mResultColumnCount; i++) {
    467    if (mColumnNames[i].Equals(aName)) {
    468      *_index = i;
    469      return NS_OK;
    470    }
    471  }
    472 
    473  return NS_ERROR_INVALID_ARG;
    474 }
    475 
    476 NS_IMETHODIMP
    477 Statement::Reset() {
    478  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    479 
    480 #ifdef DEBUG
    481  MOZ_LOG(gStorageLog, LogLevel::Debug,
    482          ("Resetting statement: '%s'", ::sqlite3_sql(mDBStatement)));
    483 
    484  checkAndLogStatementPerformance(mDBStatement);
    485 #endif
    486 
    487  mParamsArray = nullptr;
    488  (void)sqlite3_reset(mDBStatement);
    489  (void)sqlite3_clear_bindings(mDBStatement);
    490 
    491  mExecuting = false;
    492 
    493  // This will be a no-op if the status has already been recorded or if this
    494  // statement has not been executed. Async statements have their status
    495  // tracked and recorded in StatementData.
    496  MaybeRecordQueryStatus(SQLITE_OK, true);
    497  mHasExecuted = false;
    498 
    499  return NS_OK;
    500 }
    501 
    502 NS_IMETHODIMP
    503 Statement::BindParameters(mozIStorageBindingParamsArray* aParameters) {
    504  NS_ENSURE_ARG_POINTER(aParameters);
    505 
    506  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    507 
    508  BindingParamsArray* array = static_cast<BindingParamsArray*>(aParameters);
    509  if (array->getOwner() != this) return NS_ERROR_UNEXPECTED;
    510 
    511  if (array->length() == 0) return NS_ERROR_UNEXPECTED;
    512 
    513  mParamsArray = array;
    514  mParamsArray->lock();
    515 
    516  return NS_OK;
    517 }
    518 
    519 NS_IMETHODIMP
    520 Statement::Execute() {
    521  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    522 
    523  bool ret;
    524  nsresult rv = ExecuteStep(&ret);
    525  nsresult rv2 = Reset();
    526 
    527  return NS_FAILED(rv) ? rv : rv2;
    528 }
    529 
    530 NS_IMETHODIMP
    531 Statement::ExecuteStep(bool* _moreResults) {
    532  AUTO_PROFILER_LABEL("Statement::ExecuteStep", OTHER);
    533 
    534  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    535 
    536  // Bind any parameters first before executing.
    537  if (mParamsArray) {
    538    // If we have more than one row of parameters to bind, they shouldn't be
    539    // calling this method (and instead use executeAsync).
    540    if (mParamsArray->length() != 1) return NS_ERROR_UNEXPECTED;
    541 
    542    BindingParamsArray::iterator row = mParamsArray->begin();
    543    nsCOMPtr<IStorageBindingParamsInternal> bindingInternal =
    544        do_QueryInterface(*row);
    545    nsCOMPtr<mozIStorageError> error = bindingInternal->bind(mDBStatement);
    546    if (error) {
    547      int32_t srv;
    548      (void)error->GetResult(&srv);
    549      return convertResultCode(srv);
    550    }
    551 
    552    // We have bound, so now we can clear our array.
    553    mParamsArray = nullptr;
    554  }
    555  int srv = mDBConnection->stepStatement(mNativeConnection, mDBStatement);
    556  mHasExecuted = true;
    557  MaybeRecordQueryStatus(srv);
    558 
    559  if (srv != SQLITE_ROW && srv != SQLITE_DONE &&
    560      MOZ_LOG_TEST(gStorageLog, LogLevel::Debug)) {
    561    nsAutoCString errStr;
    562    (void)mDBConnection->GetLastErrorString(errStr);
    563    MOZ_LOG(gStorageLog, LogLevel::Debug,
    564            ("Statement::ExecuteStep error: %s", errStr.get()));
    565  }
    566 
    567  // SQLITE_ROW and SQLITE_DONE are non-errors
    568  if (srv == SQLITE_ROW) {
    569    // we got a row back
    570    mExecuting = true;
    571    *_moreResults = true;
    572    return NS_OK;
    573  } else if (srv == SQLITE_DONE) {
    574    // statement is done (no row returned)
    575    mExecuting = false;
    576    *_moreResults = false;
    577    return NS_OK;
    578  } else if (srv == SQLITE_BUSY || srv == SQLITE_MISUSE) {
    579    mExecuting = false;
    580  } else if (mExecuting) {
    581    MOZ_LOG(gStorageLog, LogLevel::Error,
    582            ("SQLite error after mExecuting was true!"));
    583    mExecuting = false;
    584  }
    585 
    586  return convertResultCode(srv);
    587 }
    588 
    589 NS_IMETHODIMP
    590 Statement::GetState(int32_t* _state) {
    591  if (!mDBStatement)
    592    *_state = MOZ_STORAGE_STATEMENT_INVALID;
    593  else if (mExecuting)
    594    *_state = MOZ_STORAGE_STATEMENT_EXECUTING;
    595  else
    596    *_state = MOZ_STORAGE_STATEMENT_READY;
    597 
    598  return NS_OK;
    599 }
    600 
    601 ////////////////////////////////////////////////////////////////////////////////
    602 //// mozIStorageValueArray (now part of mozIStorageStatement too)
    603 
    604 NS_IMETHODIMP
    605 Statement::GetNumEntries(uint32_t* _length) {
    606  *_length = mResultColumnCount;
    607  return NS_OK;
    608 }
    609 
    610 NS_IMETHODIMP
    611 Statement::GetTypeOfIndex(uint32_t aIndex, int32_t* _type) {
    612  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    613 
    614  ENSURE_INDEX_VALUE(aIndex, mResultColumnCount);
    615 
    616  if (!mExecuting) return NS_ERROR_UNEXPECTED;
    617 
    618  int t = ::sqlite3_column_type(mDBStatement, aIndex);
    619  switch (t) {
    620    case SQLITE_INTEGER:
    621      *_type = mozIStorageStatement::VALUE_TYPE_INTEGER;
    622      break;
    623    case SQLITE_FLOAT:
    624      *_type = mozIStorageStatement::VALUE_TYPE_FLOAT;
    625      break;
    626    case SQLITE_TEXT:
    627      *_type = mozIStorageStatement::VALUE_TYPE_TEXT;
    628      break;
    629    case SQLITE_BLOB:
    630      *_type = mozIStorageStatement::VALUE_TYPE_BLOB;
    631      break;
    632    case SQLITE_NULL:
    633      *_type = mozIStorageStatement::VALUE_TYPE_NULL;
    634      break;
    635    default:
    636      return NS_ERROR_FAILURE;
    637  }
    638 
    639  return NS_OK;
    640 }
    641 
    642 NS_IMETHODIMP
    643 Statement::GetInt32(uint32_t aIndex, int32_t* _value) {
    644  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    645 
    646  ENSURE_INDEX_VALUE(aIndex, mResultColumnCount);
    647 
    648  if (!mExecuting) return NS_ERROR_UNEXPECTED;
    649 
    650  *_value = ::sqlite3_column_int(mDBStatement, aIndex);
    651  return NS_OK;
    652 }
    653 
    654 NS_IMETHODIMP
    655 Statement::GetInt64(uint32_t aIndex, int64_t* _value) {
    656  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    657 
    658  ENSURE_INDEX_VALUE(aIndex, mResultColumnCount);
    659 
    660  if (!mExecuting) return NS_ERROR_UNEXPECTED;
    661 
    662  *_value = ::sqlite3_column_int64(mDBStatement, aIndex);
    663 
    664  return NS_OK;
    665 }
    666 
    667 NS_IMETHODIMP
    668 Statement::GetDouble(uint32_t aIndex, double* _value) {
    669  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    670 
    671  ENSURE_INDEX_VALUE(aIndex, mResultColumnCount);
    672 
    673  if (!mExecuting) return NS_ERROR_UNEXPECTED;
    674 
    675  *_value = ::sqlite3_column_double(mDBStatement, aIndex);
    676 
    677  return NS_OK;
    678 }
    679 
    680 NS_IMETHODIMP
    681 Statement::GetUTF8String(uint32_t aIndex, nsACString& _value) {
    682  // Get type of Index will check aIndex for us, so we don't have to.
    683  int32_t type;
    684  nsresult rv = GetTypeOfIndex(aIndex, &type);
    685  NS_ENSURE_SUCCESS(rv, rv);
    686  if (type == mozIStorageStatement::VALUE_TYPE_NULL) {
    687    // NULL columns should have IsVoid set to distinguish them from the empty
    688    // string.
    689    _value.SetIsVoid(true);
    690  } else {
    691    const char* value = reinterpret_cast<const char*>(
    692        ::sqlite3_column_text(mDBStatement, aIndex));
    693    _value.Assign(value, ::sqlite3_column_bytes(mDBStatement, aIndex));
    694  }
    695  return NS_OK;
    696 }
    697 
    698 NS_IMETHODIMP
    699 Statement::GetString(uint32_t aIndex, nsAString& _value) {
    700  // Get type of Index will check aIndex for us, so we don't have to.
    701  int32_t type;
    702  nsresult rv = GetTypeOfIndex(aIndex, &type);
    703  NS_ENSURE_SUCCESS(rv, rv);
    704  if (type == mozIStorageStatement::VALUE_TYPE_NULL) {
    705    // NULL columns should have IsVoid set to distinguish them from the empty
    706    // string.
    707    _value.SetIsVoid(true);
    708  } else {
    709    const char16_t* value = static_cast<const char16_t*>(
    710        ::sqlite3_column_text16(mDBStatement, aIndex));
    711    _value.Assign(value, ::sqlite3_column_bytes16(mDBStatement, aIndex) /
    712                             sizeof(char16_t));
    713  }
    714  return NS_OK;
    715 }
    716 
    717 NS_IMETHODIMP
    718 Statement::GetVariant(uint32_t aIndex, nsIVariant** _value) {
    719  if (!mDBStatement) {
    720    return NS_ERROR_NOT_INITIALIZED;
    721  }
    722 
    723  ENSURE_INDEX_VALUE(aIndex, mResultColumnCount);
    724 
    725  if (!mExecuting) {
    726    return NS_ERROR_UNEXPECTED;
    727  }
    728 
    729  nsCOMPtr<nsIVariant> variant;
    730  int type = ::sqlite3_column_type(mDBStatement, aIndex);
    731  switch (type) {
    732    case SQLITE_INTEGER:
    733      variant =
    734          new IntegerVariant(::sqlite3_column_int64(mDBStatement, aIndex));
    735      break;
    736    case SQLITE_FLOAT:
    737      variant = new FloatVariant(::sqlite3_column_double(mDBStatement, aIndex));
    738      break;
    739    case SQLITE_TEXT: {
    740      const char16_t* value = static_cast<const char16_t*>(
    741          ::sqlite3_column_text16(mDBStatement, aIndex));
    742      nsDependentString str(
    743          value,
    744          ::sqlite3_column_bytes16(mDBStatement, aIndex) / sizeof(char16_t));
    745      variant = new TextVariant(str);
    746      break;
    747    }
    748    case SQLITE_NULL:
    749      variant = new NullVariant();
    750      break;
    751    case SQLITE_BLOB: {
    752      int size = ::sqlite3_column_bytes(mDBStatement, aIndex);
    753      const void* data = ::sqlite3_column_blob(mDBStatement, aIndex);
    754      variant = new BlobVariant(std::pair<const void*, int>(data, size));
    755      break;
    756    }
    757  }
    758  NS_ENSURE_TRUE(variant, NS_ERROR_UNEXPECTED);
    759 
    760  variant.forget(_value);
    761  return NS_OK;
    762 }
    763 
    764 NS_IMETHODIMP
    765 Statement::GetBlob(uint32_t aIndex, uint32_t* _size, uint8_t** _blob) {
    766  if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;
    767 
    768  ENSURE_INDEX_VALUE(aIndex, mResultColumnCount);
    769 
    770  if (!mExecuting) return NS_ERROR_UNEXPECTED;
    771 
    772  int size = ::sqlite3_column_bytes(mDBStatement, aIndex);
    773  void* blob = nullptr;
    774  if (size) {
    775    blob = moz_xmemdup(::sqlite3_column_blob(mDBStatement, aIndex), size);
    776  }
    777 
    778  *_blob = static_cast<uint8_t*>(blob);
    779  *_size = size;
    780  return NS_OK;
    781 }
    782 
    783 NS_IMETHODIMP
    784 Statement::GetBlobAsString(uint32_t aIndex, nsAString& aValue) {
    785  return DoGetBlobAsString(this, aIndex, aValue);
    786 }
    787 
    788 NS_IMETHODIMP
    789 Statement::GetBlobAsUTF8String(uint32_t aIndex, nsACString& aValue) {
    790  return DoGetBlobAsString(this, aIndex, aValue);
    791 }
    792 
    793 NS_IMETHODIMP
    794 Statement::GetSharedUTF8String(uint32_t aIndex, uint32_t* _byteLength,
    795                               const char** _value) {
    796  *_value = reinterpret_cast<const char*>(
    797      ::sqlite3_column_text(mDBStatement, aIndex));
    798  if (_byteLength) {
    799    *_byteLength = ::sqlite3_column_bytes(mDBStatement, aIndex);
    800  }
    801  return NS_OK;
    802 }
    803 
    804 NS_IMETHODIMP
    805 Statement::GetSharedString(uint32_t aIndex, uint32_t* _byteLength,
    806                           const char16_t** _value) {
    807  *_value = static_cast<const char16_t*>(
    808      ::sqlite3_column_text16(mDBStatement, aIndex));
    809  if (_byteLength) {
    810    *_byteLength = ::sqlite3_column_bytes16(mDBStatement, aIndex);
    811  }
    812  return NS_OK;
    813 }
    814 
    815 NS_IMETHODIMP
    816 Statement::GetSharedBlob(uint32_t aIndex, uint32_t* _byteLength,
    817                         const uint8_t** _blob) {
    818  *_blob =
    819      static_cast<const uint8_t*>(::sqlite3_column_blob(mDBStatement, aIndex));
    820  if (_byteLength) {
    821    *_byteLength = ::sqlite3_column_bytes(mDBStatement, aIndex);
    822  }
    823  return NS_OK;
    824 }
    825 
    826 NS_IMETHODIMP
    827 Statement::GetIsNull(uint32_t aIndex, bool* _isNull) {
    828  // Get type of Index will check aIndex for us, so we don't have to.
    829  int32_t type;
    830  nsresult rv = GetTypeOfIndex(aIndex, &type);
    831  NS_ENSURE_SUCCESS(rv, rv);
    832  *_isNull = (type == mozIStorageStatement::VALUE_TYPE_NULL);
    833  return NS_OK;
    834 }
    835 
    836 ////////////////////////////////////////////////////////////////////////////////
    837 //// mozIStorageBindingParams
    838 
    839 BOILERPLATE_BIND_PROXIES(Statement,
    840                         if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED;)
    841 
    842 }  // namespace storage
    843 }  // namespace mozilla
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE