/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ : * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include <limits.h> #include <stdio.h> #include "nsError.h" #include "nsMemory.h" #include "nsThreadUtils.h" #include "nsIClassInfoImpl.h" #include "Variant.h" #include "mozIStorageError.h" #include "mozStorageBindingParams.h" #include "mozStorageConnection.h" #include "mozStorageStatementJSHelper.h" #include "mozStoragePrivateHelpers.h" #include "mozStorageStatementParams.h" #include "mozStorageStatementRow.h" #include "mozStorageStatement.h" #include "GeckoProfiler.h" #include "nsDOMClassInfo.h" #include "mozilla/Logging.h" extern mozilla::LazyLogModule gStorageLog; namespace mozilla { namespace storage { //////////////////////////////////////////////////////////////////////////////// //// nsIClassInfo NS_IMPL_CI_INTERFACE_GETTER(Statement, mozIStorageStatement, mozIStorageBaseStatement, mozIStorageBindingParams, mozIStorageValueArray, mozilla::storage::StorageBaseStatementInternal) class StatementClassInfo : public nsIClassInfo { public: constexpr StatementClassInfo() {} NS_DECL_ISUPPORTS_INHERITED NS_IMETHOD GetInterfaces(uint32_t *_count, nsIID ***_array) override { return NS_CI_INTERFACE_GETTER_NAME(Statement)(_count, _array); } NS_IMETHOD GetScriptableHelper(nsIXPCScriptable **_helper) override { static StatementJSHelper sJSHelper; *_helper = &sJSHelper; return NS_OK; } NS_IMETHOD GetContractID(char **_contractID) override { *_contractID = nullptr; return NS_OK; } NS_IMETHOD GetClassDescription(char **_desc) override { *_desc = nullptr; return NS_OK; } NS_IMETHOD GetClassID(nsCID **_id) override { *_id = nullptr; return NS_OK; } NS_IMETHOD GetFlags(uint32_t *_flags) override { *_flags = 0; return NS_OK; } NS_IMETHOD GetClassIDNoAlloc(nsCID *_cid) override { return NS_ERROR_NOT_AVAILABLE; } }; NS_IMETHODIMP_(MozExternalRefCountType) StatementClassInfo::AddRef() { return 2; } NS_IMETHODIMP_(MozExternalRefCountType) StatementClassInfo::Release() { return 1; } NS_IMPL_QUERY_INTERFACE(StatementClassInfo, nsIClassInfo) static StatementClassInfo sStatementClassInfo; //////////////////////////////////////////////////////////////////////////////// //// Statement Statement::Statement() : StorageBaseStatementInternal() , mDBStatement(nullptr) , mColumnNames() , mExecuting(false) { } nsresult Statement::initialize(Connection *aDBConnection, sqlite3 *aNativeConnection, const nsACString &aSQLStatement) { MOZ_ASSERT(aDBConnection, "No database connection given!"); MOZ_ASSERT(!aDBConnection->isClosed(), "Database connection should be valid"); MOZ_ASSERT(!mDBStatement, "Statement already initialized!"); MOZ_ASSERT(aNativeConnection, "No native connection given!"); int srv = aDBConnection->prepareStatement(aNativeConnection, PromiseFlatCString(aSQLStatement), &mDBStatement); if (srv != SQLITE_OK) { MOZ_LOG(gStorageLog, LogLevel::Error, ("Sqlite statement prepare error: %d '%s'", srv, ::sqlite3_errmsg(aNativeConnection))); MOZ_LOG(gStorageLog, LogLevel::Error, ("Statement was: '%s'", PromiseFlatCString(aSQLStatement).get())); return NS_ERROR_FAILURE; } MOZ_LOG(gStorageLog, LogLevel::Debug, ("Initialized statement '%s' (0x%p)", PromiseFlatCString(aSQLStatement).get(), mDBStatement)); mDBConnection = aDBConnection; mNativeConnection = aNativeConnection; mParamCount = ::sqlite3_bind_parameter_count(mDBStatement); mResultColumnCount = ::sqlite3_column_count(mDBStatement); mColumnNames.Clear(); nsCString* columnNames = mColumnNames.AppendElements(mResultColumnCount); for (uint32_t i = 0; i < mResultColumnCount; i++) { const char *name = ::sqlite3_column_name(mDBStatement, i); columnNames[i].Assign(name); } #ifdef DEBUG // We want to try and test for LIKE and that consumers are using // escapeStringForLIKE instead of just trusting user input. The idea to // check to see if they are binding a parameter after like instead of just // using a string. We only do this in debug builds because it's expensive! const nsCaseInsensitiveCStringComparator c; nsACString::const_iterator start, end, e; aSQLStatement.BeginReading(start); aSQLStatement.EndReading(end); e = end; while (::FindInReadable(NS_LITERAL_CSTRING(" LIKE"), start, e, c)) { // We have a LIKE in here, so we perform our tests // FindInReadable moves the iterator, so we have to get a new one for // each test we perform. nsACString::const_iterator s1, s2, s3; s1 = s2 = s3 = start; if (!(::FindInReadable(NS_LITERAL_CSTRING(" LIKE ?"), s1, end, c) || ::FindInReadable(NS_LITERAL_CSTRING(" LIKE :"), s2, end, c) || ::FindInReadable(NS_LITERAL_CSTRING(" LIKE @"), s3, end, c))) { // At this point, we didn't find a LIKE statement followed by ?, :, // or @, all of which are valid characters for binding a parameter. // We will warn the consumer that they may not be safely using LIKE. NS_WARNING("Unsafe use of LIKE detected! Please ensure that you " "are using mozIStorageStatement::escapeStringForLIKE " "and that you are binding that result to the statement " "to prevent SQL injection attacks."); } // resetting start and e start = e; e = end; } #endif return NS_OK; } mozIStorageBindingParams * Statement::getParams() { nsresult rv; // If we do not have an array object yet, make it. if (!mParamsArray) { nsCOMPtr<mozIStorageBindingParamsArray> array; rv = NewBindingParamsArray(getter_AddRefs(array)); NS_ENSURE_SUCCESS(rv, nullptr); mParamsArray = static_cast<BindingParamsArray *>(array.get()); } // If there isn't already any rows added, we'll have to add one to use. if (mParamsArray->length() == 0) { RefPtr<BindingParams> params(new BindingParams(mParamsArray, this)); NS_ENSURE_TRUE(params, nullptr); rv = mParamsArray->AddParams(params); NS_ENSURE_SUCCESS(rv, nullptr); // We have to unlock our params because AddParams locks them. This is safe // because no reference to the params object was, or ever will be given out. params->unlock(this); // We also want to lock our array at this point - we don't want anything to // be added to it. Nothing has, or will ever get a reference to it, but we // will get additional safety checks via assertions by doing this. mParamsArray->lock(); } return *mParamsArray->begin(); } Statement::~Statement() { (void)internalFinalize(true); } //////////////////////////////////////////////////////////////////////////////// //// nsISupports NS_IMPL_ADDREF(Statement) NS_IMPL_RELEASE(Statement) NS_INTERFACE_MAP_BEGIN(Statement) NS_INTERFACE_MAP_ENTRY(mozIStorageStatement) NS_INTERFACE_MAP_ENTRY(mozIStorageBaseStatement) NS_INTERFACE_MAP_ENTRY(mozIStorageBindingParams) NS_INTERFACE_MAP_ENTRY(mozIStorageValueArray) NS_INTERFACE_MAP_ENTRY(mozilla::storage::StorageBaseStatementInternal) if (aIID.Equals(NS_GET_IID(nsIClassInfo))) { foundInterface = static_cast<nsIClassInfo *>(&sStatementClassInfo); } else NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozIStorageStatement) NS_INTERFACE_MAP_END //////////////////////////////////////////////////////////////////////////////// //// StorageBaseStatementInternal Connection * Statement::getOwner() { return mDBConnection; } int Statement::getAsyncStatement(sqlite3_stmt **_stmt) { // If we have no statement, we shouldn't be calling this method! NS_ASSERTION(mDBStatement != nullptr, "We have no statement to clone!"); // If we do not yet have a cached async statement, clone our statement now. if (!mAsyncStatement) { nsDependentCString sql(::sqlite3_sql(mDBStatement)); int rc = mDBConnection->prepareStatement(mNativeConnection, sql, &mAsyncStatement); if (rc != SQLITE_OK) { *_stmt = nullptr; return rc; } MOZ_LOG(gStorageLog, LogLevel::Debug, ("Cloned statement 0x%p to 0x%p", mDBStatement, mAsyncStatement)); } *_stmt = mAsyncStatement; return SQLITE_OK; } nsresult Statement::getAsynchronousStatementData(StatementData &_data) { if (!mDBStatement) return NS_ERROR_UNEXPECTED; sqlite3_stmt *stmt; int rc = getAsyncStatement(&stmt); if (rc != SQLITE_OK) return convertResultCode(rc); _data = StatementData(stmt, bindingParamsArray(), this); return NS_OK; } already_AddRefed<mozIStorageBindingParams> Statement::newBindingParams(mozIStorageBindingParamsArray *aOwner) { nsCOMPtr<mozIStorageBindingParams> params = new BindingParams(aOwner, this); return params.forget(); } //////////////////////////////////////////////////////////////////////////////// //// mozIStorageStatement // proxy to StorageBaseStatementInternal using its define helper. MIXIN_IMPL_STORAGEBASESTATEMENTINTERNAL(Statement, (void)0;) NS_IMETHODIMP Statement::Clone(mozIStorageStatement **_statement) { RefPtr<Statement> statement(new Statement()); NS_ENSURE_TRUE(statement, NS_ERROR_OUT_OF_MEMORY); nsAutoCString sql(::sqlite3_sql(mDBStatement)); nsresult rv = statement->initialize(mDBConnection, mNativeConnection, sql); NS_ENSURE_SUCCESS(rv, rv); statement.forget(_statement); return NS_OK; } NS_IMETHODIMP Statement::Finalize() { return internalFinalize(false); } nsresult Statement::internalFinalize(bool aDestructing) { if (!mDBStatement) return NS_OK; int srv = SQLITE_OK; if (!mDBConnection->isClosed()) { // // The connection is still open. While statement finalization and // closing may, in some cases, take place in two distinct threads, // we have a guarantee that the connection will remain open until // this method terminates: // // a. The connection will be closed synchronously. In this case, // there is no race condition, as everything takes place on the // same thread. // // b. The connection is closed asynchronously and this code is // executed on the opener thread. In this case, asyncClose() has // not been called yet and will not be called before we return // from this function. // // c. The connection is closed asynchronously and this code is // executed on the async execution thread. In this case, // AsyncCloseConnection::Run() has not been called yet and will // not be called before we return from this function. // // In either case, the connection is still valid, hence closing // here is safe. // MOZ_LOG(gStorageLog, LogLevel::Debug, ("Finalizing statement '%s' during garbage-collection", ::sqlite3_sql(mDBStatement))); srv = ::sqlite3_finalize(mDBStatement); } #ifdef DEBUG else { // // The database connection is either closed or closing. The sqlite // statement has either been finalized already by the connection // or is about to be finalized by the connection. // // Finalizing it here would be useless and segfaultish. // char *msg = ::PR_smprintf("SQL statement (%x) should have been finalized" " before garbage-collection. For more details on this statement, set" " NSPR_LOG_MESSAGES=mozStorage:5 .", mDBStatement); // // Note that we can't display the statement itself, as the data structure // is not valid anymore. However, the address shown here should help // developers correlate with the more complete debug message triggered // by AsyncClose(). // #if 0 // Deactivate the warning until we have fixed the exising culprit // (see bug 914070). NS_WARNING(msg); #endif // 0 MOZ_LOG(gStorageLog, LogLevel::Warning, (msg)); ::PR_smprintf_free(msg); } #endif mDBStatement = nullptr; if (mAsyncStatement) { // If the destructor called us, there are no pending async statements (they // hold a reference to us) and we can/must just kill the statement directly. if (aDestructing) destructorAsyncFinalize(); else asyncFinalize(); } // Release the holders, so they can release the reference to us. mStatementParamsHolder = nullptr; mStatementRowHolder = nullptr; return convertResultCode(srv); } NS_IMETHODIMP Statement::GetParameterCount(uint32_t *_parameterCount) { if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; *_parameterCount = mParamCount; return NS_OK; } NS_IMETHODIMP Statement::GetParameterName(uint32_t aParamIndex, nsACString &_name) { if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; ENSURE_INDEX_VALUE(aParamIndex, mParamCount); const char *name = ::sqlite3_bind_parameter_name(mDBStatement, aParamIndex + 1); if (name == nullptr) { // this thing had no name, so fake one nsAutoCString fakeName(":"); fakeName.AppendInt(aParamIndex); _name.Assign(fakeName); } else { _name.Assign(nsDependentCString(name)); } return NS_OK; } NS_IMETHODIMP Statement::GetParameterIndex(const nsACString &aName, uint32_t *_index) { if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; // We do not accept any forms of names other than ":name", but we need to add // the colon for SQLite. nsAutoCString name(":"); name.Append(aName); int ind = ::sqlite3_bind_parameter_index(mDBStatement, name.get()); if (ind == 0) // Named parameter not found. return NS_ERROR_INVALID_ARG; *_index = ind - 1; // SQLite indexes are 1-based, we are 0-based. return NS_OK; } NS_IMETHODIMP Statement::GetColumnCount(uint32_t *_columnCount) { if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; *_columnCount = mResultColumnCount; return NS_OK; } NS_IMETHODIMP Statement::GetColumnName(uint32_t aColumnIndex, nsACString &_name) { if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; ENSURE_INDEX_VALUE(aColumnIndex, mResultColumnCount); const char *cname = ::sqlite3_column_name(mDBStatement, aColumnIndex); _name.Assign(nsDependentCString(cname)); return NS_OK; } NS_IMETHODIMP Statement::GetColumnIndex(const nsACString &aName, uint32_t *_index) { if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; // Surprisingly enough, SQLite doesn't provide an API for this. We have to // determine it ourselves sadly. for (uint32_t i = 0; i < mResultColumnCount; i++) { if (mColumnNames[i].Equals(aName)) { *_index = i; return NS_OK; } } return NS_ERROR_INVALID_ARG; } NS_IMETHODIMP Statement::Reset() { if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; #ifdef DEBUG MOZ_LOG(gStorageLog, LogLevel::Debug, ("Resetting statement: '%s'", ::sqlite3_sql(mDBStatement))); checkAndLogStatementPerformance(mDBStatement); #endif mParamsArray = nullptr; (void)sqlite3_reset(mDBStatement); (void)sqlite3_clear_bindings(mDBStatement); mExecuting = false; return NS_OK; } NS_IMETHODIMP Statement::BindParameters(mozIStorageBindingParamsArray *aParameters) { NS_ENSURE_ARG_POINTER(aParameters); if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; BindingParamsArray *array = static_cast<BindingParamsArray *>(aParameters); if (array->getOwner() != this) return NS_ERROR_UNEXPECTED; if (array->length() == 0) return NS_ERROR_UNEXPECTED; mParamsArray = array; mParamsArray->lock(); return NS_OK; } NS_IMETHODIMP Statement::Execute() { if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; bool ret; nsresult rv = ExecuteStep(&ret); nsresult rv2 = Reset(); return NS_FAILED(rv) ? rv : rv2; } NS_IMETHODIMP Statement::ExecuteStep(bool *_moreResults) { PROFILER_LABEL("Statement", "ExecuteStep", js::ProfileEntry::Category::STORAGE); if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; // Bind any parameters first before executing. if (mParamsArray) { // If we have more than one row of parameters to bind, they shouldn't be // calling this method (and instead use executeAsync). if (mParamsArray->length() != 1) return NS_ERROR_UNEXPECTED; BindingParamsArray::iterator row = mParamsArray->begin(); nsCOMPtr<IStorageBindingParamsInternal> bindingInternal = do_QueryInterface(*row); nsCOMPtr<mozIStorageError> error = bindingInternal->bind(mDBStatement); if (error) { int32_t srv; (void)error->GetResult(&srv); return convertResultCode(srv); } // We have bound, so now we can clear our array. mParamsArray = nullptr; } int srv = mDBConnection->stepStatement(mNativeConnection, mDBStatement); if (srv != SQLITE_ROW && srv != SQLITE_DONE && MOZ_LOG_TEST(gStorageLog, LogLevel::Debug)) { nsAutoCString errStr; (void)mDBConnection->GetLastErrorString(errStr); MOZ_LOG(gStorageLog, LogLevel::Debug, ("Statement::ExecuteStep error: %s", errStr.get())); } // SQLITE_ROW and SQLITE_DONE are non-errors if (srv == SQLITE_ROW) { // we got a row back mExecuting = true; *_moreResults = true; return NS_OK; } else if (srv == SQLITE_DONE) { // statement is done (no row returned) mExecuting = false; *_moreResults = false; return NS_OK; } else if (srv == SQLITE_BUSY || srv == SQLITE_MISUSE) { mExecuting = false; } else if (mExecuting) { MOZ_LOG(gStorageLog, LogLevel::Error, ("SQLite error after mExecuting was true!")); mExecuting = false; } return convertResultCode(srv); } NS_IMETHODIMP Statement::GetState(int32_t *_state) { if (!mDBStatement) *_state = MOZ_STORAGE_STATEMENT_INVALID; else if (mExecuting) *_state = MOZ_STORAGE_STATEMENT_EXECUTING; else *_state = MOZ_STORAGE_STATEMENT_READY; return NS_OK; } //////////////////////////////////////////////////////////////////////////////// //// mozIStorageValueArray (now part of mozIStorageStatement too) NS_IMETHODIMP Statement::GetNumEntries(uint32_t *_length) { *_length = mResultColumnCount; return NS_OK; } NS_IMETHODIMP Statement::GetTypeOfIndex(uint32_t aIndex, int32_t *_type) { if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; ENSURE_INDEX_VALUE(aIndex, mResultColumnCount); if (!mExecuting) return NS_ERROR_UNEXPECTED; int t = ::sqlite3_column_type(mDBStatement, aIndex); switch (t) { case SQLITE_INTEGER: *_type = mozIStorageStatement::VALUE_TYPE_INTEGER; break; case SQLITE_FLOAT: *_type = mozIStorageStatement::VALUE_TYPE_FLOAT; break; case SQLITE_TEXT: *_type = mozIStorageStatement::VALUE_TYPE_TEXT; break; case SQLITE_BLOB: *_type = mozIStorageStatement::VALUE_TYPE_BLOB; break; case SQLITE_NULL: *_type = mozIStorageStatement::VALUE_TYPE_NULL; break; default: return NS_ERROR_FAILURE; } return NS_OK; } NS_IMETHODIMP Statement::GetInt32(uint32_t aIndex, int32_t *_value) { if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; ENSURE_INDEX_VALUE(aIndex, mResultColumnCount); if (!mExecuting) return NS_ERROR_UNEXPECTED; *_value = ::sqlite3_column_int(mDBStatement, aIndex); return NS_OK; } NS_IMETHODIMP Statement::GetInt64(uint32_t aIndex, int64_t *_value) { if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; ENSURE_INDEX_VALUE(aIndex, mResultColumnCount); if (!mExecuting) return NS_ERROR_UNEXPECTED; *_value = ::sqlite3_column_int64(mDBStatement, aIndex); return NS_OK; } NS_IMETHODIMP Statement::GetDouble(uint32_t aIndex, double *_value) { if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; ENSURE_INDEX_VALUE(aIndex, mResultColumnCount); if (!mExecuting) return NS_ERROR_UNEXPECTED; *_value = ::sqlite3_column_double(mDBStatement, aIndex); return NS_OK; } NS_IMETHODIMP Statement::GetUTF8String(uint32_t aIndex, nsACString &_value) { // Get type of Index will check aIndex for us, so we don't have to. int32_t type; nsresult rv = GetTypeOfIndex(aIndex, &type); NS_ENSURE_SUCCESS(rv, rv); if (type == mozIStorageStatement::VALUE_TYPE_NULL) { // NULL columns should have IsVoid set to distinguish them from the empty // string. _value.SetIsVoid(true); } else { const char *value = reinterpret_cast<const char *>(::sqlite3_column_text(mDBStatement, aIndex)); _value.Assign(value, ::sqlite3_column_bytes(mDBStatement, aIndex)); } return NS_OK; } NS_IMETHODIMP Statement::GetString(uint32_t aIndex, nsAString &_value) { // Get type of Index will check aIndex for us, so we don't have to. int32_t type; nsresult rv = GetTypeOfIndex(aIndex, &type); NS_ENSURE_SUCCESS(rv, rv); if (type == mozIStorageStatement::VALUE_TYPE_NULL) { // NULL columns should have IsVoid set to distinguish them from the empty // string. _value.SetIsVoid(true); } else { const char16_t *value = static_cast<const char16_t *>(::sqlite3_column_text16(mDBStatement, aIndex)); _value.Assign(value, ::sqlite3_column_bytes16(mDBStatement, aIndex) / 2); } return NS_OK; } NS_IMETHODIMP Statement::GetBlob(uint32_t aIndex, uint32_t *_size, uint8_t **_blob) { if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; ENSURE_INDEX_VALUE(aIndex, mResultColumnCount); if (!mExecuting) return NS_ERROR_UNEXPECTED; int size = ::sqlite3_column_bytes(mDBStatement, aIndex); void *blob = nullptr; if (size) { blob = nsMemory::Clone(::sqlite3_column_blob(mDBStatement, aIndex), size); NS_ENSURE_TRUE(blob, NS_ERROR_OUT_OF_MEMORY); } *_blob = static_cast<uint8_t *>(blob); *_size = size; return NS_OK; } NS_IMETHODIMP Statement::GetBlobAsString(uint32_t aIndex, nsAString& aValue) { return DoGetBlobAsString(this, aIndex, aValue); } NS_IMETHODIMP Statement::GetBlobAsUTF8String(uint32_t aIndex, nsACString& aValue) { return DoGetBlobAsString(this, aIndex, aValue); } NS_IMETHODIMP Statement::GetSharedUTF8String(uint32_t aIndex, uint32_t *_length, const char **_value) { if (_length) *_length = ::sqlite3_column_bytes(mDBStatement, aIndex); *_value = reinterpret_cast<const char *>(::sqlite3_column_text(mDBStatement, aIndex)); return NS_OK; } NS_IMETHODIMP Statement::GetSharedString(uint32_t aIndex, uint32_t *_length, const char16_t **_value) { if (_length) *_length = ::sqlite3_column_bytes16(mDBStatement, aIndex); *_value = static_cast<const char16_t *>(::sqlite3_column_text16(mDBStatement, aIndex)); return NS_OK; } NS_IMETHODIMP Statement::GetSharedBlob(uint32_t aIndex, uint32_t *_size, const uint8_t **_blob) { *_size = ::sqlite3_column_bytes(mDBStatement, aIndex); *_blob = static_cast<const uint8_t *>(::sqlite3_column_blob(mDBStatement, aIndex)); return NS_OK; } NS_IMETHODIMP Statement::GetIsNull(uint32_t aIndex, bool *_isNull) { // Get type of Index will check aIndex for us, so we don't have to. int32_t type; nsresult rv = GetTypeOfIndex(aIndex, &type); NS_ENSURE_SUCCESS(rv, rv); *_isNull = (type == mozIStorageStatement::VALUE_TYPE_NULL); return NS_OK; } //////////////////////////////////////////////////////////////////////////////// //// mozIStorageBindingParams BOILERPLATE_BIND_PROXIES( Statement, if (!mDBStatement) return NS_ERROR_NOT_INITIALIZED; ) } // namespace storage } // namespace mozilla