diff options
Diffstat (limited to 'storage/mozStorageConnection.cpp')
| -rw-r--r-- | storage/mozStorageConnection.cpp | 2040 |
1 files changed, 2040 insertions, 0 deletions
diff --git a/storage/mozStorageConnection.cpp b/storage/mozStorageConnection.cpp new file mode 100644 index 000000000..10297fca1 --- /dev/null +++ b/storage/mozStorageConnection.cpp @@ -0,0 +1,2040 @@ +/* -*- 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 <stdio.h> + +#include "nsError.h" +#include "nsIMutableArray.h" +#include "nsAutoPtr.h" +#include "nsIMemoryReporter.h" +#include "nsThreadUtils.h" +#include "nsIFile.h" +#include "nsIFileURL.h" +#include "mozilla/Telemetry.h" +#include "mozilla/Mutex.h" +#include "mozilla/CondVar.h" +#include "mozilla/Attributes.h" +#include "mozilla/ErrorNames.h" +#include "mozilla/Unused.h" +#include "mozilla/dom/quota/QuotaObject.h" + +#include "mozIStorageAggregateFunction.h" +#include "mozIStorageCompletionCallback.h" +#include "mozIStorageFunction.h" + +#include "mozStorageAsyncStatementExecution.h" +#include "mozStorageSQLFunctions.h" +#include "mozStorageConnection.h" +#include "mozStorageService.h" +#include "mozStorageStatement.h" +#include "mozStorageAsyncStatement.h" +#include "mozStorageArgValueArray.h" +#include "mozStoragePrivateHelpers.h" +#include "mozStorageStatementData.h" +#include "StorageBaseStatementInternal.h" +#include "SQLCollations.h" +#include "FileSystemModule.h" +#include "mozStorageHelper.h" +#include "GeckoProfiler.h" + +#include "mozilla/Logging.h" +#include "prprf.h" +#include "nsProxyRelease.h" +#include <algorithm> + +#define MIN_AVAILABLE_BYTES_PER_CHUNKED_GROWTH 524288000 // 500 MiB + +// Maximum size of the pages cache per connection. +#define MAX_CACHE_SIZE_KIBIBYTES 2048 // 2 MiB + +mozilla::LazyLogModule gStorageLog("mozStorage"); + +// Checks that the protected code is running on the main-thread only if the +// connection was also opened on it. +#ifdef DEBUG +#define CHECK_MAINTHREAD_ABUSE() \ + do { \ + nsCOMPtr<nsIThread> mainThread = do_GetMainThread(); \ + NS_WARNING_ASSERTION( \ + threadOpenedOn == mainThread || !NS_IsMainThread(), \ + "Using Storage synchronous API on main-thread, but the connection was " \ + "opened on another thread."); \ + } while(0) +#else +#define CHECK_MAINTHREAD_ABUSE() do { /* Nothing */ } while(0) +#endif + +namespace mozilla { +namespace storage { + +using mozilla::dom::quota::QuotaObject; + +namespace { + +int +nsresultToSQLiteResult(nsresult aXPCOMResultCode) +{ + if (NS_SUCCEEDED(aXPCOMResultCode)) { + return SQLITE_OK; + } + + switch (aXPCOMResultCode) { + case NS_ERROR_FILE_CORRUPTED: + return SQLITE_CORRUPT; + case NS_ERROR_FILE_ACCESS_DENIED: + return SQLITE_CANTOPEN; + case NS_ERROR_STORAGE_BUSY: + return SQLITE_BUSY; + case NS_ERROR_FILE_IS_LOCKED: + return SQLITE_LOCKED; + case NS_ERROR_FILE_READ_ONLY: + return SQLITE_READONLY; + case NS_ERROR_STORAGE_IOERR: + return SQLITE_IOERR; + case NS_ERROR_FILE_NO_DEVICE_SPACE: + return SQLITE_FULL; + case NS_ERROR_OUT_OF_MEMORY: + return SQLITE_NOMEM; + case NS_ERROR_UNEXPECTED: + return SQLITE_MISUSE; + case NS_ERROR_ABORT: + return SQLITE_ABORT; + case NS_ERROR_STORAGE_CONSTRAINT: + return SQLITE_CONSTRAINT; + default: + return SQLITE_ERROR; + } + + MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("Must return in switch above!"); +} + +//////////////////////////////////////////////////////////////////////////////// +//// Variant Specialization Functions (variantToSQLiteT) + +int +sqlite3_T_int(sqlite3_context *aCtx, + int aValue) +{ + ::sqlite3_result_int(aCtx, aValue); + return SQLITE_OK; +} + +int +sqlite3_T_int64(sqlite3_context *aCtx, + sqlite3_int64 aValue) +{ + ::sqlite3_result_int64(aCtx, aValue); + return SQLITE_OK; +} + +int +sqlite3_T_double(sqlite3_context *aCtx, + double aValue) +{ + ::sqlite3_result_double(aCtx, aValue); + return SQLITE_OK; +} + +int +sqlite3_T_text(sqlite3_context *aCtx, + const nsCString &aValue) +{ + ::sqlite3_result_text(aCtx, + aValue.get(), + aValue.Length(), + SQLITE_TRANSIENT); + return SQLITE_OK; +} + +int +sqlite3_T_text16(sqlite3_context *aCtx, + const nsString &aValue) +{ + ::sqlite3_result_text16(aCtx, + aValue.get(), + aValue.Length() * 2, // Number of bytes. + SQLITE_TRANSIENT); + return SQLITE_OK; +} + +int +sqlite3_T_null(sqlite3_context *aCtx) +{ + ::sqlite3_result_null(aCtx); + return SQLITE_OK; +} + +int +sqlite3_T_blob(sqlite3_context *aCtx, + const void *aData, + int aSize) +{ + ::sqlite3_result_blob(aCtx, aData, aSize, free); + return SQLITE_OK; +} + +#include "variantToSQLiteT_impl.h" + +//////////////////////////////////////////////////////////////////////////////// +//// Modules + +struct Module +{ + const char* name; + int (*registerFunc)(sqlite3*, const char*); +}; + +Module gModules[] = { + { "filesystem", RegisterFileSystemModule } +}; + +//////////////////////////////////////////////////////////////////////////////// +//// Local Functions + +int tracefunc (unsigned aReason, void *aClosure, void *aP, void *aX) +{ + switch (aReason) { + case SQLITE_TRACE_STMT: { + // aP is a pointer to the prepared statement. + sqlite3_stmt* stmt = static_cast<sqlite3_stmt*>(aP); + // aX is a pointer to a string containing the unexpanded SQL or a comment, + // starting with "--"" in case of a trigger. + char* expanded = static_cast<char*>(aX); + // Simulate what sqlite_trace was doing. + if (!::strncmp(expanded, "--", 2)) { + MOZ_LOG(gStorageLog, LogLevel::Debug, + ("TRACE_STMT on %p: '%s'", aClosure, expanded)); + } else { + char* sql = ::sqlite3_expanded_sql(stmt); + MOZ_LOG(gStorageLog, LogLevel::Debug, + ("TRACE_STMT on %p: '%s'", aClosure, sql)); + ::sqlite3_free(sql); + } + break; + } + case SQLITE_TRACE_PROFILE: { + // aX is pointer to a 64bit integer containing nanoseconds it took to + // execute the last command. + sqlite_int64 time = *(static_cast<sqlite_int64*>(aX)) / 1000000; + if (time > 0) { + MOZ_LOG(gStorageLog, LogLevel::Debug, + ("TRACE_TIME on %p: %dms", aClosure, time)); + } + break; + } + } + return 0; +} + +void +basicFunctionHelper(sqlite3_context *aCtx, + int aArgc, + sqlite3_value **aArgv) +{ + void *userData = ::sqlite3_user_data(aCtx); + + mozIStorageFunction *func = static_cast<mozIStorageFunction *>(userData); + + RefPtr<ArgValueArray> arguments(new ArgValueArray(aArgc, aArgv)); + if (!arguments) + return; + + nsCOMPtr<nsIVariant> result; + nsresult rv = func->OnFunctionCall(arguments, getter_AddRefs(result)); + if (NS_FAILED(rv)) { + nsAutoCString errorMessage; + GetErrorName(rv, errorMessage); + errorMessage.InsertLiteral("User function returned ", 0); + errorMessage.Append('!'); + + NS_WARNING(errorMessage.get()); + + ::sqlite3_result_error(aCtx, errorMessage.get(), -1); + ::sqlite3_result_error_code(aCtx, nsresultToSQLiteResult(rv)); + return; + } + int retcode = variantToSQLiteT(aCtx, result); + if (retcode == SQLITE_IGNORE) { + ::sqlite3_result_int(aCtx, SQLITE_IGNORE); + } else if (retcode != SQLITE_OK) { + NS_WARNING("User function returned invalid data type!"); + ::sqlite3_result_error(aCtx, + "User function returned invalid data type", + -1); + } +} + +void +aggregateFunctionStepHelper(sqlite3_context *aCtx, + int aArgc, + sqlite3_value **aArgv) +{ + void *userData = ::sqlite3_user_data(aCtx); + mozIStorageAggregateFunction *func = + static_cast<mozIStorageAggregateFunction *>(userData); + + RefPtr<ArgValueArray> arguments(new ArgValueArray(aArgc, aArgv)); + if (!arguments) + return; + + if (NS_FAILED(func->OnStep(arguments))) + NS_WARNING("User aggregate step function returned error code!"); +} + +void +aggregateFunctionFinalHelper(sqlite3_context *aCtx) +{ + void *userData = ::sqlite3_user_data(aCtx); + mozIStorageAggregateFunction *func = + static_cast<mozIStorageAggregateFunction *>(userData); + + RefPtr<nsIVariant> result; + if (NS_FAILED(func->OnFinal(getter_AddRefs(result)))) { + NS_WARNING("User aggregate final function returned error code!"); + ::sqlite3_result_error(aCtx, + "User aggregate final function returned error code", + -1); + return; + } + + if (variantToSQLiteT(aCtx, result) != SQLITE_OK) { + NS_WARNING("User aggregate final function returned invalid data type!"); + ::sqlite3_result_error(aCtx, + "User aggregate final function returned invalid data type", + -1); + } +} + +/** + * This code is heavily based on the sample at: + * http://www.sqlite.org/unlock_notify.html + */ +class UnlockNotification +{ +public: + UnlockNotification() + : mMutex("UnlockNotification mMutex") + , mCondVar(mMutex, "UnlockNotification condVar") + , mSignaled(false) + { + } + + void Wait() + { + MutexAutoLock lock(mMutex); + while (!mSignaled) { + (void)mCondVar.Wait(); + } + } + + void Signal() + { + MutexAutoLock lock(mMutex); + mSignaled = true; + (void)mCondVar.Notify(); + } + +private: + Mutex mMutex; + CondVar mCondVar; + bool mSignaled; +}; + +void +UnlockNotifyCallback(void **aArgs, + int aArgsSize) +{ + for (int i = 0; i < aArgsSize; i++) { + UnlockNotification *notification = + static_cast<UnlockNotification *>(aArgs[i]); + notification->Signal(); + } +} + +int +WaitForUnlockNotify(sqlite3* aDatabase) +{ + UnlockNotification notification; + int srv = ::sqlite3_unlock_notify(aDatabase, UnlockNotifyCallback, + ¬ification); + MOZ_ASSERT(srv == SQLITE_LOCKED || srv == SQLITE_OK); + if (srv == SQLITE_OK) { + notification.Wait(); + } + + return srv; +} + +} // namespace + +//////////////////////////////////////////////////////////////////////////////// +//// Local Classes + +namespace { + +class AsyncCloseConnection final: public Runnable +{ +public: + AsyncCloseConnection(Connection *aConnection, + sqlite3 *aNativeConnection, + nsIRunnable *aCallbackEvent, + already_AddRefed<nsIThread> aAsyncExecutionThread) + : mConnection(aConnection) + , mNativeConnection(aNativeConnection) + , mCallbackEvent(aCallbackEvent) + , mAsyncExecutionThread(aAsyncExecutionThread) + { + } + + NS_IMETHOD Run() override + { +#ifdef DEBUG + // This code is executed on the background thread + bool onAsyncThread = false; + (void)mAsyncExecutionThread->IsOnCurrentThread(&onAsyncThread); + MOZ_ASSERT(onAsyncThread); +#endif // DEBUG + + nsCOMPtr<nsIRunnable> event = NewRunnableMethod<nsCOMPtr<nsIThread>> + (mConnection, &Connection::shutdownAsyncThread, mAsyncExecutionThread); + (void)NS_DispatchToMainThread(event); + + // Internal close. + (void)mConnection->internalClose(mNativeConnection); + + // Callback + if (mCallbackEvent) { + nsCOMPtr<nsIThread> thread; + (void)NS_GetMainThread(getter_AddRefs(thread)); + (void)thread->Dispatch(mCallbackEvent, NS_DISPATCH_NORMAL); + } + + return NS_OK; + } + + ~AsyncCloseConnection() { + NS_ReleaseOnMainThread(mConnection.forget()); + NS_ReleaseOnMainThread(mCallbackEvent.forget()); + } +private: + RefPtr<Connection> mConnection; + sqlite3 *mNativeConnection; + nsCOMPtr<nsIRunnable> mCallbackEvent; + nsCOMPtr<nsIThread> mAsyncExecutionThread; +}; + +/** + * An event used to initialize the clone of a connection. + * + * Must be executed on the clone's async execution thread. + */ +class AsyncInitializeClone final: public Runnable +{ +public: + /** + * @param aConnection The connection being cloned. + * @param aClone The clone. + * @param aReadOnly If |true|, the clone is read only. + * @param aCallback A callback to trigger once initialization + * is complete. This event will be called on + * aClone->threadOpenedOn. + */ + AsyncInitializeClone(Connection* aConnection, + Connection* aClone, + const bool aReadOnly, + mozIStorageCompletionCallback* aCallback) + : mConnection(aConnection) + , mClone(aClone) + , mReadOnly(aReadOnly) + , mCallback(aCallback) + { + MOZ_ASSERT(NS_IsMainThread()); + } + + NS_IMETHOD Run() override { + MOZ_ASSERT (NS_GetCurrentThread() == mConnection->getAsyncExecutionTarget()); + + nsresult rv = mConnection->initializeClone(mClone, mReadOnly); + if (NS_FAILED(rv)) { + return Dispatch(rv, nullptr); + } + return Dispatch(NS_OK, + NS_ISUPPORTS_CAST(mozIStorageAsyncConnection*, mClone)); + } + +private: + nsresult Dispatch(nsresult aResult, nsISupports* aValue) { + RefPtr<CallbackComplete> event = new CallbackComplete(aResult, + aValue, + mCallback.forget()); + return mClone->threadOpenedOn->Dispatch(event, NS_DISPATCH_NORMAL); + } + + ~AsyncInitializeClone() { + nsCOMPtr<nsIThread> thread; + DebugOnly<nsresult> rv = NS_GetMainThread(getter_AddRefs(thread)); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + + // Handle ambiguous nsISupports inheritance. + NS_ProxyRelease(thread, mConnection.forget()); + NS_ProxyRelease(thread, mClone.forget()); + + // Generally, the callback will be released by CallbackComplete. + // However, if for some reason Run() is not executed, we still + // need to ensure that it is released here. + NS_ProxyRelease(thread, mCallback.forget()); + } + + RefPtr<Connection> mConnection; + RefPtr<Connection> mClone; + const bool mReadOnly; + nsCOMPtr<mozIStorageCompletionCallback> mCallback; +}; + +} // namespace + +//////////////////////////////////////////////////////////////////////////////// +//// Connection + +Connection::Connection(Service *aService, + int aFlags, + bool aAsyncOnly, + bool aIgnoreLockingMode) +: sharedAsyncExecutionMutex("Connection::sharedAsyncExecutionMutex") +, sharedDBMutex("Connection::sharedDBMutex") +, threadOpenedOn(do_GetCurrentThread()) +, mDBConn(nullptr) +, mAsyncExecutionThreadShuttingDown(false) +#ifdef DEBUG +, mAsyncExecutionThreadIsAlive(false) +#endif +, mConnectionClosed(false) +, mTransactionInProgress(false) +, mProgressHandler(nullptr) +, mFlags(aFlags) +, mIgnoreLockingMode(aIgnoreLockingMode) +, mStorageService(aService) +, mAsyncOnly(aAsyncOnly) +{ + MOZ_ASSERT(!mIgnoreLockingMode || mFlags & SQLITE_OPEN_READONLY, + "Can't ignore locking for a non-readonly connection!"); + mStorageService->registerConnection(this); +} + +Connection::~Connection() +{ + (void)Close(); + + MOZ_ASSERT(!mAsyncExecutionThread, + "AsyncClose has not been invoked on this connection!"); + MOZ_ASSERT(!mAsyncExecutionThreadIsAlive, + "The async execution thread should have been shutdown!"); +} + +NS_IMPL_ADDREF(Connection) + +NS_INTERFACE_MAP_BEGIN(Connection) + NS_INTERFACE_MAP_ENTRY(mozIStorageAsyncConnection) + NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor) + NS_INTERFACE_MAP_ENTRY_CONDITIONAL(mozIStorageConnection, !mAsyncOnly) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozIStorageConnection) +NS_INTERFACE_MAP_END + +// This is identical to what NS_IMPL_RELEASE provides, but with the +// extra |1 == count| case. +NS_IMETHODIMP_(MozExternalRefCountType) Connection::Release(void) +{ + NS_PRECONDITION(0 != mRefCnt, "dup release"); + nsrefcnt count = --mRefCnt; + NS_LOG_RELEASE(this, count, "Connection"); + if (1 == count) { + // If the refcount is 1, the single reference must be from + // gService->mConnections (in class |Service|). Which means we can + // unregister it safely. + mStorageService->unregisterConnection(this); + } else if (0 == count) { + mRefCnt = 1; /* stabilize */ +#if 0 /* enable this to find non-threadsafe destructors: */ + NS_ASSERT_OWNINGTHREAD(Connection); +#endif + delete (this); + return 0; + } + return count; +} + +int32_t +Connection::getSqliteRuntimeStatus(int32_t aStatusOption, int32_t* aMaxValue) +{ + MOZ_ASSERT(mDBConn, "A connection must exist at this point"); + int curr = 0, max = 0; + DebugOnly<int> rc = ::sqlite3_db_status(mDBConn, aStatusOption, &curr, &max, 0); + MOZ_ASSERT(NS_SUCCEEDED(convertResultCode(rc))); + if (aMaxValue) + *aMaxValue = max; + return curr; +} + +nsIEventTarget * +Connection::getAsyncExecutionTarget() +{ + MutexAutoLock lockedScope(sharedAsyncExecutionMutex); + + // If we are shutting down the asynchronous thread, don't hand out any more + // references to the thread. + if (mAsyncExecutionThreadShuttingDown) + return nullptr; + + if (!mAsyncExecutionThread) { + nsresult rv = ::NS_NewThread(getter_AddRefs(mAsyncExecutionThread)); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to create async thread."); + return nullptr; + } + static nsThreadPoolNaming naming; + naming.SetThreadPoolName(NS_LITERAL_CSTRING("mozStorage"), + mAsyncExecutionThread); + } + +#ifdef DEBUG + mAsyncExecutionThreadIsAlive = true; +#endif + + return mAsyncExecutionThread; +} + +nsresult +Connection::initialize() +{ + NS_ASSERTION (!mDBConn, "Initialize called on already opened database!"); + MOZ_ASSERT(!mIgnoreLockingMode, "Can't ignore locking on an in-memory db."); + PROFILER_LABEL("mozStorageConnection", "initialize", + js::ProfileEntry::Category::STORAGE); + + // in memory database requested, sqlite uses a magic file name + int srv = ::sqlite3_open_v2(":memory:", &mDBConn, mFlags, nullptr); + if (srv != SQLITE_OK) { + mDBConn = nullptr; + return convertResultCode(srv); + } + + // Do not set mDatabaseFile or mFileURL here since this is a "memory" + // database. + + nsresult rv = initializeInternal(); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Connection::initialize(nsIFile *aDatabaseFile) +{ + NS_ASSERTION (aDatabaseFile, "Passed null file!"); + NS_ASSERTION (!mDBConn, "Initialize called on already opened database!"); + PROFILER_LABEL("mozStorageConnection", "initialize", + js::ProfileEntry::Category::STORAGE); + + mDatabaseFile = aDatabaseFile; + + nsAutoString path; + nsresult rv = aDatabaseFile->GetPath(path); + NS_ENSURE_SUCCESS(rv, rv); + +#ifdef XP_WIN + static const char* sIgnoreLockingVFS = "win32-none"; +#else + static const char* sIgnoreLockingVFS = "unix-none"; +#endif + const char* vfs = mIgnoreLockingMode ? sIgnoreLockingVFS : nullptr; + + int srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn, + mFlags, vfs); + if (srv != SQLITE_OK) { + mDBConn = nullptr; + return convertResultCode(srv); + } + + // Do not set mFileURL here since this is database does not have an associated + // URL. + mDatabaseFile = aDatabaseFile; + + rv = initializeInternal(); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Connection::initialize(nsIFileURL *aFileURL) +{ + NS_ASSERTION (aFileURL, "Passed null file URL!"); + NS_ASSERTION (!mDBConn, "Initialize called on already opened database!"); + PROFILER_LABEL("mozStorageConnection", "initialize", + js::ProfileEntry::Category::STORAGE); + + nsCOMPtr<nsIFile> databaseFile; + nsresult rv = aFileURL->GetFile(getter_AddRefs(databaseFile)); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoCString spec; + rv = aFileURL->GetSpec(spec); + NS_ENSURE_SUCCESS(rv, rv); + + int srv = ::sqlite3_open_v2(spec.get(), &mDBConn, mFlags, nullptr); + if (srv != SQLITE_OK) { + mDBConn = nullptr; + return convertResultCode(srv); + } + + // Set both mDatabaseFile and mFileURL here. + mFileURL = aFileURL; + mDatabaseFile = databaseFile; + + rv = initializeInternal(); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Connection::initializeInternal() +{ + MOZ_ASSERT(mDBConn); + + if (mFileURL) { + const char* dbPath = ::sqlite3_db_filename(mDBConn, "main"); + MOZ_ASSERT(dbPath); + + const char* telemetryFilename = + ::sqlite3_uri_parameter(dbPath, "telemetryFilename"); + if (telemetryFilename) { + if (NS_WARN_IF(*telemetryFilename == '\0')) { + return NS_ERROR_INVALID_ARG; + } + mTelemetryFilename = telemetryFilename; + } + } + + if (mTelemetryFilename.IsEmpty()) { + mTelemetryFilename = getFilename(); + MOZ_ASSERT(!mTelemetryFilename.IsEmpty()); + } + + // Properly wrap the database handle's mutex. + sharedDBMutex.initWithMutex(sqlite3_db_mutex(mDBConn)); + + // SQLite tracing can slow down queries (especially long queries) + // significantly. Don't trace unless the user is actively monitoring SQLite. + if (MOZ_LOG_TEST(gStorageLog, LogLevel::Debug)) { + ::sqlite3_trace_v2(mDBConn, + SQLITE_TRACE_STMT | SQLITE_TRACE_PROFILE, + tracefunc, this); + + MOZ_LOG(gStorageLog, LogLevel::Debug, ("Opening connection to '%s' (%p)", + mTelemetryFilename.get(), this)); + } + + int64_t pageSize = Service::getDefaultPageSize(); + + // Set page_size to the preferred default value. This is effective only if + // the database has just been created, otherwise, if the database does not + // use WAL journal mode, a VACUUM operation will updated its page_size. + nsAutoCString pageSizeQuery(MOZ_STORAGE_UNIQUIFY_QUERY_STR + "PRAGMA page_size = "); + pageSizeQuery.AppendInt(pageSize); + nsresult rv = ExecuteSimpleSQL(pageSizeQuery); + NS_ENSURE_SUCCESS(rv, rv); + + // Setting the cache_size forces the database open, verifying if it is valid + // or corrupt. So this is executed regardless it being actually needed. + // The cache_size is calculated from the actual page_size, to save memory. + nsAutoCString cacheSizeQuery(MOZ_STORAGE_UNIQUIFY_QUERY_STR + "PRAGMA cache_size = "); + cacheSizeQuery.AppendInt(-MAX_CACHE_SIZE_KIBIBYTES); + int srv = executeSql(mDBConn, cacheSizeQuery.get()); + if (srv != SQLITE_OK) { + ::sqlite3_close(mDBConn); + mDBConn = nullptr; + return convertResultCode(srv); + } + +#if defined(MOZ_MEMORY_TEMP_STORE_PRAGMA) + (void)ExecuteSimpleSQL(NS_LITERAL_CSTRING("PRAGMA temp_store = 2;")); +#endif + + // Register our built-in SQL functions. + srv = registerFunctions(mDBConn); + if (srv != SQLITE_OK) { + ::sqlite3_close(mDBConn); + mDBConn = nullptr; + return convertResultCode(srv); + } + + // Register our built-in SQL collating sequences. + srv = registerCollations(mDBConn, mStorageService); + if (srv != SQLITE_OK) { + ::sqlite3_close(mDBConn); + mDBConn = nullptr; + return convertResultCode(srv); + } + + // Set the synchronous PRAGMA, according to the preference. + switch (Service::getSynchronousPref()) { + case 2: + (void)ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "PRAGMA synchronous = FULL;")); + break; + case 0: + (void)ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "PRAGMA synchronous = OFF;")); + break; + case 1: + default: + (void)ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "PRAGMA synchronous = NORMAL;")); + break; + } + + return NS_OK; +} + +nsresult +Connection::databaseElementExists(enum DatabaseElementType aElementType, + const nsACString &aElementName, + bool *_exists) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + // When constructing the query, make sure to SELECT the correct db's sqlite_master + // if the user is prefixing the element with a specific db. ex: sample.test + nsCString query("SELECT name FROM (SELECT * FROM "); + nsDependentCSubstring element; + int32_t ind = aElementName.FindChar('.'); + if (ind == kNotFound) { + element.Assign(aElementName); + } + else { + nsDependentCSubstring db(Substring(aElementName, 0, ind + 1)); + element.Assign(Substring(aElementName, ind + 1, aElementName.Length())); + query.Append(db); + } + query.AppendLiteral("sqlite_master UNION ALL SELECT * FROM sqlite_temp_master) WHERE type = '"); + + switch (aElementType) { + case INDEX: + query.AppendLiteral("index"); + break; + case TABLE: + query.AppendLiteral("table"); + break; + } + query.AppendLiteral("' AND name ='"); + query.Append(element); + query.Append('\''); + + sqlite3_stmt *stmt; + int srv = prepareStatement(mDBConn, query, &stmt); + if (srv != SQLITE_OK) + return convertResultCode(srv); + + srv = stepStatement(mDBConn, stmt); + // we just care about the return value from step + (void)::sqlite3_finalize(stmt); + + if (srv == SQLITE_ROW) { + *_exists = true; + return NS_OK; + } + if (srv == SQLITE_DONE) { + *_exists = false; + return NS_OK; + } + + return convertResultCode(srv); +} + +bool +Connection::findFunctionByInstance(nsISupports *aInstance) +{ + sharedDBMutex.assertCurrentThreadOwns(); + + for (auto iter = mFunctions.Iter(); !iter.Done(); iter.Next()) { + if (iter.UserData().function == aInstance) { + return true; + } + } + return false; +} + +/* static */ int +Connection::sProgressHelper(void *aArg) +{ + Connection *_this = static_cast<Connection *>(aArg); + return _this->progressHandler(); +} + +int +Connection::progressHandler() +{ + sharedDBMutex.assertCurrentThreadOwns(); + if (mProgressHandler) { + bool result; + nsresult rv = mProgressHandler->OnProgress(this, &result); + if (NS_FAILED(rv)) return 0; // Don't break request + return result ? 1 : 0; + } + return 0; +} + +nsresult +Connection::setClosedState() +{ + // Ensure that we are on the correct thread to close the database. + bool onOpenedThread; + nsresult rv = threadOpenedOn->IsOnCurrentThread(&onOpenedThread); + NS_ENSURE_SUCCESS(rv, rv); + if (!onOpenedThread) { + NS_ERROR("Must close the database on the thread that you opened it with!"); + return NS_ERROR_UNEXPECTED; + } + + // Flag that we are shutting down the async thread, so that + // getAsyncExecutionTarget knows not to expose/create the async thread. + { + MutexAutoLock lockedScope(sharedAsyncExecutionMutex); + NS_ENSURE_FALSE(mAsyncExecutionThreadShuttingDown, NS_ERROR_UNEXPECTED); + mAsyncExecutionThreadShuttingDown = true; + } + + // Set the property to null before closing the connection, otherwise the other + // functions in the module may try to use the connection after it is closed. + mDBConn = nullptr; + + return NS_OK; +} + +bool +Connection::connectionReady() +{ + return mDBConn != nullptr; +} + +bool +Connection::isClosing() +{ + bool shuttingDown = false; + { + MutexAutoLock lockedScope(sharedAsyncExecutionMutex); + shuttingDown = mAsyncExecutionThreadShuttingDown; + } + return shuttingDown && !isClosed(); +} + +bool +Connection::isClosed() +{ + MutexAutoLock lockedScope(sharedAsyncExecutionMutex); + return mConnectionClosed; +} + +void +Connection::shutdownAsyncThread(nsIThread *aThread) { + MOZ_ASSERT(!mAsyncExecutionThread); + MOZ_ASSERT(mAsyncExecutionThreadIsAlive); + MOZ_ASSERT(mAsyncExecutionThreadShuttingDown); + + DebugOnly<nsresult> rv = aThread->Shutdown(); + MOZ_ASSERT(NS_SUCCEEDED(rv)); +#ifdef DEBUG + mAsyncExecutionThreadIsAlive = false; +#endif +} + +nsresult +Connection::internalClose(sqlite3 *aNativeConnection) +{ + // Sanity checks to make sure we are in the proper state before calling this. + // aNativeConnection can be null if OpenAsyncDatabase failed and is now just + // cleaning up the async thread. + MOZ_ASSERT(!isClosed()); + +#ifdef DEBUG + { // Make sure we have marked our async thread as shutting down. + MutexAutoLock lockedScope(sharedAsyncExecutionMutex); + NS_ASSERTION(mAsyncExecutionThreadShuttingDown, + "Did not call setClosedState!"); + } +#endif // DEBUG + + if (MOZ_LOG_TEST(gStorageLog, LogLevel::Debug)) { + nsAutoCString leafName(":memory"); + if (mDatabaseFile) + (void)mDatabaseFile->GetNativeLeafName(leafName); + MOZ_LOG(gStorageLog, LogLevel::Debug, ("Closing connection to '%s'", + leafName.get())); + } + + // At this stage, we may still have statements that need to be + // finalized. Attempt to close the database connection. This will + // always disconnect any virtual tables and cleanly finalize their + // internal statements. Once this is done, closing may fail due to + // unfinalized client statements, in which case we need to finalize + // these statements and close again. + { + MutexAutoLock lockedScope(sharedAsyncExecutionMutex); + mConnectionClosed = true; + } + + // Nothing else needs to be done if we don't have a connection here. + if (!aNativeConnection) + return NS_OK; + + int srv = sqlite3_close(aNativeConnection); + + if (srv == SQLITE_BUSY) { + // We still have non-finalized statements. Finalize them. + + sqlite3_stmt *stmt = nullptr; + while ((stmt = ::sqlite3_next_stmt(aNativeConnection, stmt))) { + MOZ_LOG(gStorageLog, LogLevel::Debug, + ("Auto-finalizing SQL statement '%s' (%x)", + ::sqlite3_sql(stmt), + stmt)); + +#ifdef DEBUG + char *msg = ::PR_smprintf("SQL statement '%s' (%x) should have been finalized before closing the connection", + ::sqlite3_sql(stmt), + stmt); + NS_WARNING(msg); + ::PR_smprintf_free(msg); + msg = nullptr; +#endif // DEBUG + + srv = ::sqlite3_finalize(stmt); + +#ifdef DEBUG + if (srv != SQLITE_OK) { + msg = ::PR_smprintf("Could not finalize SQL statement '%s' (%x)", + ::sqlite3_sql(stmt), + stmt); + NS_WARNING(msg); + ::PR_smprintf_free(msg); + msg = nullptr; + } +#endif // DEBUG + + // Ensure that the loop continues properly, whether closing has succeeded + // or not. + if (srv == SQLITE_OK) { + stmt = nullptr; + } + } + + // Now that all statements have been finalized, we + // should be able to close. + srv = ::sqlite3_close(aNativeConnection); + + } + + if (srv != SQLITE_OK) { + MOZ_ASSERT(srv == SQLITE_OK, + "sqlite3_close failed. There are probably outstanding statements that are listed above!"); + } + + return convertResultCode(srv); +} + +nsCString +Connection::getFilename() +{ + nsCString leafname(":memory:"); + if (mDatabaseFile) { + (void)mDatabaseFile->GetNativeLeafName(leafname); + } + return leafname; +} + +int +Connection::stepStatement(sqlite3 *aNativeConnection, sqlite3_stmt *aStatement) +{ + MOZ_ASSERT(aStatement); + bool checkedMainThread = false; + TimeStamp startTime = TimeStamp::Now(); + + // The connection may have been closed if the executing statement has been + // created and cached after a call to asyncClose() but before the actual + // sqlite3_close(). This usually happens when other tasks using cached + // statements are asynchronously scheduled for execution and any of them ends + // up after asyncClose. See bug 728653 for details. + if (isClosed()) + return SQLITE_MISUSE; + + (void)::sqlite3_extended_result_codes(aNativeConnection, 1); + + int srv; + while ((srv = ::sqlite3_step(aStatement)) == SQLITE_LOCKED_SHAREDCACHE) { + if (!checkedMainThread) { + checkedMainThread = true; + if (::NS_IsMainThread()) { + NS_WARNING("We won't allow blocking on the main thread!"); + break; + } + } + + srv = WaitForUnlockNotify(aNativeConnection); + if (srv != SQLITE_OK) { + break; + } + + ::sqlite3_reset(aStatement); + } + + // Report very slow SQL statements to Telemetry + TimeDuration duration = TimeStamp::Now() - startTime; + const uint32_t threshold = + NS_IsMainThread() ? Telemetry::kSlowSQLThresholdForMainThread + : Telemetry::kSlowSQLThresholdForHelperThreads; + if (duration.ToMilliseconds() >= threshold) { + nsDependentCString statementString(::sqlite3_sql(aStatement)); + Telemetry::RecordSlowSQLStatement(statementString, mTelemetryFilename, + duration.ToMilliseconds()); + } + + (void)::sqlite3_extended_result_codes(aNativeConnection, 0); + // Drop off the extended result bits of the result code. + return srv & 0xFF; +} + +int +Connection::prepareStatement(sqlite3 *aNativeConnection, const nsCString &aSQL, + sqlite3_stmt **_stmt) +{ + // We should not even try to prepare statements after the connection has + // been closed. + if (isClosed()) + return SQLITE_MISUSE; + + bool checkedMainThread = false; + + (void)::sqlite3_extended_result_codes(aNativeConnection, 1); + + int srv; + while((srv = ::sqlite3_prepare_v2(aNativeConnection, + aSQL.get(), + -1, + _stmt, + nullptr)) == SQLITE_LOCKED_SHAREDCACHE) { + if (!checkedMainThread) { + checkedMainThread = true; + if (::NS_IsMainThread()) { + NS_WARNING("We won't allow blocking on the main thread!"); + break; + } + } + + srv = WaitForUnlockNotify(aNativeConnection); + if (srv != SQLITE_OK) { + break; + } + } + + if (srv != SQLITE_OK) { + nsCString warnMsg; + warnMsg.AppendLiteral("The SQL statement '"); + warnMsg.Append(aSQL); + warnMsg.AppendLiteral("' could not be compiled due to an error: "); + warnMsg.Append(::sqlite3_errmsg(aNativeConnection)); + +#ifdef DEBUG + NS_WARNING(warnMsg.get()); +#endif + MOZ_LOG(gStorageLog, LogLevel::Error, ("%s", warnMsg.get())); + } + + (void)::sqlite3_extended_result_codes(aNativeConnection, 0); + // Drop off the extended result bits of the result code. + int rc = srv & 0xFF; + // sqlite will return OK on a comment only string and set _stmt to nullptr. + // The callers of this function are used to only checking the return value, + // so it is safer to return an error code. + if (rc == SQLITE_OK && *_stmt == nullptr) { + return SQLITE_MISUSE; + } + + return rc; +} + + +int +Connection::executeSql(sqlite3 *aNativeConnection, const char *aSqlString) +{ + if (isClosed()) + return SQLITE_MISUSE; + + TimeStamp startTime = TimeStamp::Now(); + int srv = ::sqlite3_exec(aNativeConnection, aSqlString, nullptr, nullptr, + nullptr); + + // Report very slow SQL statements to Telemetry + TimeDuration duration = TimeStamp::Now() - startTime; + const uint32_t threshold = + NS_IsMainThread() ? Telemetry::kSlowSQLThresholdForMainThread + : Telemetry::kSlowSQLThresholdForHelperThreads; + if (duration.ToMilliseconds() >= threshold) { + nsDependentCString statementString(aSqlString); + Telemetry::RecordSlowSQLStatement(statementString, mTelemetryFilename, + duration.ToMilliseconds()); + } + + return srv; +} + +//////////////////////////////////////////////////////////////////////////////// +//// nsIInterfaceRequestor + +NS_IMETHODIMP +Connection::GetInterface(const nsIID &aIID, + void **_result) +{ + if (aIID.Equals(NS_GET_IID(nsIEventTarget))) { + nsIEventTarget *background = getAsyncExecutionTarget(); + NS_IF_ADDREF(background); + *_result = background; + return NS_OK; + } + return NS_ERROR_NO_INTERFACE; +} + +//////////////////////////////////////////////////////////////////////////////// +//// mozIStorageConnection + +NS_IMETHODIMP +Connection::Close() +{ + if (!mDBConn) + return NS_ERROR_NOT_INITIALIZED; + + { // Make sure we have not executed any asynchronous statements. + // If this fails, the mDBConn will be left open, resulting in a leak. + // Ideally we'd schedule some code to destroy the mDBConn once all its + // async statements have finished executing; see bug 704030. + MutexAutoLock lockedScope(sharedAsyncExecutionMutex); + bool asyncCloseWasCalled = !mAsyncExecutionThread; + NS_ENSURE_TRUE(asyncCloseWasCalled, NS_ERROR_UNEXPECTED); + } + + // setClosedState nullifies our connection pointer, so we take a raw pointer + // off it, to pass it through the close procedure. + sqlite3 *nativeConn = mDBConn; + nsresult rv = setClosedState(); + NS_ENSURE_SUCCESS(rv, rv); + + return internalClose(nativeConn); +} + +NS_IMETHODIMP +Connection::AsyncClose(mozIStorageCompletionCallback *aCallback) +{ + if (!NS_IsMainThread()) { + return NS_ERROR_NOT_SAME_THREAD; + } + + // The two relevant factors at this point are whether we have a database + // connection and whether we have an async execution thread. Here's what the + // states mean and how we handle them: + // + // - (mDBConn && asyncThread): The expected case where we are either an + // async connection or a sync connection that has been used asynchronously. + // Either way the caller must call us and not Close(). Nothing surprising + // about this. We'll dispatch AsyncCloseConnection to the already-existing + // async thread. + // + // - (mDBConn && !asyncThread): A somewhat unusual case where the caller + // opened the connection synchronously and was planning to use it + // asynchronously, but never got around to using it asynchronously before + // needing to shutdown. This has been observed to happen for the cookie + // service in a case where Firefox shuts itself down almost immediately + // after startup (for unknown reasons). In the Firefox shutdown case, + // we may also fail to create a new async execution thread if one does not + // already exist. (nsThreadManager will refuse to create new threads when + // it has already been told to shutdown.) As such, we need to handle a + // failure to create the async execution thread by falling back to + // synchronous Close() and also dispatching the completion callback because + // at least Places likes to spin a nested event loop that depends on the + // callback being invoked. + // + // Note that we have considered not trying to spin up the async execution + // thread in this case if it does not already exist, but the overhead of + // thread startup (if successful) is significantly less expensive than the + // worst-case potential I/O hit of synchronously closing a database when we + // could close it asynchronously. + // + // - (!mDBConn && asyncThread): This happens in some but not all cases where + // OpenAsyncDatabase encountered a problem opening the database. If it + // happened in all cases AsyncInitDatabase would just shut down the thread + // directly and we would avoid this case. But it doesn't, so for simplicity + // and consistency AsyncCloseConnection knows how to handle this and we + // act like this was the (mDBConn && asyncThread) case in this method. + // + // - (!mDBConn && !asyncThread): The database was never successfully opened or + // Close() or AsyncClose() has already been called (at least) once. This is + // undeniably a misuse case by the caller. We could optimize for this + // case by adding an additional check of mAsyncExecutionThread without using + // getAsyncExecutionTarget() to avoid wastefully creating a thread just to + // shut it down. But this complicates the method for broken caller code + // whereas we're still correct and safe without the special-case. + nsIEventTarget *asyncThread = getAsyncExecutionTarget(); + + // Create our callback event if we were given a callback. This will + // eventually be dispatched in all cases, even if we fall back to Close() and + // the database wasn't open and we return an error. The rationale is that + // no existing consumer checks our return value and several of them like to + // spin nested event loops until the callback fires. Given that, it seems + // preferable for us to dispatch the callback in all cases. (Except the + // wrong thread misuse case we bailed on up above. But that's okay because + // that is statically wrong whereas these edge cases are dynamic.) + nsCOMPtr<nsIRunnable> completeEvent; + if (aCallback) { + completeEvent = newCompletionEvent(aCallback); + } + + if (!asyncThread) { + // We were unable to create an async thread, so we need to fall back to + // using normal Close(). Since there is no async thread, Close() will + // not complain about that. (Close() may, however, complain if the + // connection is closed, but that's okay.) + if (completeEvent) { + // Closing the database is more important than returning an error code + // about a failure to dispatch, especially because all existing native + // callers ignore our return value. + Unused << NS_DispatchToMainThread(completeEvent.forget()); + } + return Close(); + } + + // setClosedState nullifies our connection pointer, so we take a raw pointer + // off it, to pass it through the close procedure. + sqlite3 *nativeConn = mDBConn; + nsresult rv = setClosedState(); + NS_ENSURE_SUCCESS(rv, rv); + + // Create and dispatch our close event to the background thread. + nsCOMPtr<nsIRunnable> closeEvent; + { + // We need to lock because we're modifying mAsyncExecutionThread + MutexAutoLock lockedScope(sharedAsyncExecutionMutex); + closeEvent = new AsyncCloseConnection(this, + nativeConn, + completeEvent, + mAsyncExecutionThread.forget()); + } + + rv = asyncThread->Dispatch(closeEvent, NS_DISPATCH_NORMAL); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +NS_IMETHODIMP +Connection::AsyncClone(bool aReadOnly, + mozIStorageCompletionCallback *aCallback) +{ + PROFILER_LABEL("mozStorageConnection", "AsyncClone", + js::ProfileEntry::Category::STORAGE); + + if (!NS_IsMainThread()) { + return NS_ERROR_NOT_SAME_THREAD; + } + if (!mDBConn) + return NS_ERROR_NOT_INITIALIZED; + if (!mDatabaseFile) + return NS_ERROR_UNEXPECTED; + + int flags = mFlags; + if (aReadOnly) { + // Turn off SQLITE_OPEN_READWRITE, and set SQLITE_OPEN_READONLY. + flags = (~SQLITE_OPEN_READWRITE & flags) | SQLITE_OPEN_READONLY; + // Turn off SQLITE_OPEN_CREATE. + flags = (~SQLITE_OPEN_CREATE & flags); + } + + RefPtr<Connection> clone = new Connection(mStorageService, flags, + mAsyncOnly); + + RefPtr<AsyncInitializeClone> initEvent = + new AsyncInitializeClone(this, clone, aReadOnly, aCallback); + // Dispatch to our async thread, since the originating connection must remain + // valid and open for the whole cloning process. This also ensures we are + // properly serialized with a `close` operation, rather than race with it. + nsCOMPtr<nsIEventTarget> target = getAsyncExecutionTarget(); + if (!target) { + return NS_ERROR_UNEXPECTED; + } + return target->Dispatch(initEvent, NS_DISPATCH_NORMAL); +} + +nsresult +Connection::initializeClone(Connection* aClone, bool aReadOnly) +{ + nsresult rv = mFileURL ? aClone->initialize(mFileURL) + : aClone->initialize(mDatabaseFile); + if (NS_FAILED(rv)) { + return rv; + } + + // Re-attach on-disk databases that were attached to the original connection. + { + nsCOMPtr<mozIStorageStatement> stmt; + rv = CreateStatement(NS_LITERAL_CSTRING("PRAGMA database_list"), + getter_AddRefs(stmt)); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + bool hasResult = false; + while (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) { + nsAutoCString name; + rv = stmt->GetUTF8String(1, name); + if (NS_SUCCEEDED(rv) && !name.Equals(NS_LITERAL_CSTRING("main")) && + !name.Equals(NS_LITERAL_CSTRING("temp"))) { + nsCString path; + rv = stmt->GetUTF8String(2, path); + if (NS_SUCCEEDED(rv) && !path.IsEmpty()) { + rv = aClone->ExecuteSimpleSQL(NS_LITERAL_CSTRING("ATTACH DATABASE '") + + path + NS_LITERAL_CSTRING("' AS ") + name); + MOZ_ASSERT(NS_SUCCEEDED(rv), "couldn't re-attach database to cloned connection"); + } + } + } + } + + // Copy over pragmas from the original connection. + static const char * pragmas[] = { + "cache_size", + "temp_store", + "foreign_keys", + "journal_size_limit", + "synchronous", + "wal_autocheckpoint", + "busy_timeout" + }; + for (uint32_t i = 0; i < ArrayLength(pragmas); ++i) { + // Read-only connections just need cache_size and temp_store pragmas. + if (aReadOnly && ::strcmp(pragmas[i], "cache_size") != 0 && + ::strcmp(pragmas[i], "temp_store") != 0) { + continue; + } + + nsAutoCString pragmaQuery("PRAGMA "); + pragmaQuery.Append(pragmas[i]); + nsCOMPtr<mozIStorageStatement> stmt; + rv = CreateStatement(pragmaQuery, getter_AddRefs(stmt)); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + bool hasResult = false; + if (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) { + pragmaQuery.AppendLiteral(" = "); + pragmaQuery.AppendInt(stmt->AsInt32(0)); + rv = aClone->ExecuteSimpleSQL(pragmaQuery); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + } + } + + // Copy any functions that have been added to this connection. + SQLiteMutexAutoLock lockedScope(sharedDBMutex); + for (auto iter = mFunctions.Iter(); !iter.Done(); iter.Next()) { + const nsACString &key = iter.Key(); + Connection::FunctionInfo data = iter.UserData(); + + MOZ_ASSERT(data.type == Connection::FunctionInfo::SIMPLE || + data.type == Connection::FunctionInfo::AGGREGATE, + "Invalid function type!"); + + if (data.type == Connection::FunctionInfo::SIMPLE) { + mozIStorageFunction *function = + static_cast<mozIStorageFunction *>(data.function.get()); + rv = aClone->CreateFunction(key, data.numArgs, function); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to copy function to cloned connection"); + } + + } else { + mozIStorageAggregateFunction *function = + static_cast<mozIStorageAggregateFunction *>(data.function.get()); + rv = aClone->CreateAggregateFunction(key, data.numArgs, function); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to copy aggregate function to cloned connection"); + } + } + } + + return NS_OK; +} + +NS_IMETHODIMP +Connection::Clone(bool aReadOnly, + mozIStorageConnection **_connection) +{ + MOZ_ASSERT(threadOpenedOn == NS_GetCurrentThread()); + + PROFILER_LABEL("mozStorageConnection", "Clone", + js::ProfileEntry::Category::STORAGE); + + if (!mDBConn) + return NS_ERROR_NOT_INITIALIZED; + if (!mDatabaseFile) + return NS_ERROR_UNEXPECTED; + + int flags = mFlags; + if (aReadOnly) { + // Turn off SQLITE_OPEN_READWRITE, and set SQLITE_OPEN_READONLY. + flags = (~SQLITE_OPEN_READWRITE & flags) | SQLITE_OPEN_READONLY; + // Turn off SQLITE_OPEN_CREATE. + flags = (~SQLITE_OPEN_CREATE & flags); + } + + RefPtr<Connection> clone = new Connection(mStorageService, flags, + mAsyncOnly); + + nsresult rv = initializeClone(clone, aReadOnly); + if (NS_FAILED(rv)) { + return rv; + } + + NS_IF_ADDREF(*_connection = clone); + return NS_OK; +} + +NS_IMETHODIMP +Connection::GetDefaultPageSize(int32_t *_defaultPageSize) +{ + *_defaultPageSize = Service::getDefaultPageSize(); + return NS_OK; +} + +NS_IMETHODIMP +Connection::GetConnectionReady(bool *_ready) +{ + *_ready = connectionReady(); + return NS_OK; +} + +NS_IMETHODIMP +Connection::GetDatabaseFile(nsIFile **_dbFile) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + NS_IF_ADDREF(*_dbFile = mDatabaseFile); + + return NS_OK; +} + +NS_IMETHODIMP +Connection::GetLastInsertRowID(int64_t *_id) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + sqlite_int64 id = ::sqlite3_last_insert_rowid(mDBConn); + *_id = id; + + return NS_OK; +} + +NS_IMETHODIMP +Connection::GetAffectedRows(int32_t *_rows) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + *_rows = ::sqlite3_changes(mDBConn); + + return NS_OK; +} + +NS_IMETHODIMP +Connection::GetLastError(int32_t *_error) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + *_error = ::sqlite3_errcode(mDBConn); + + return NS_OK; +} + +NS_IMETHODIMP +Connection::GetLastErrorString(nsACString &_errorString) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + const char *serr = ::sqlite3_errmsg(mDBConn); + _errorString.Assign(serr); + + return NS_OK; +} + +NS_IMETHODIMP +Connection::GetSchemaVersion(int32_t *_version) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + nsCOMPtr<mozIStorageStatement> stmt; + (void)CreateStatement(NS_LITERAL_CSTRING("PRAGMA user_version"), + getter_AddRefs(stmt)); + NS_ENSURE_TRUE(stmt, NS_ERROR_OUT_OF_MEMORY); + + *_version = 0; + bool hasResult; + if (NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) + *_version = stmt->AsInt32(0); + + return NS_OK; +} + +NS_IMETHODIMP +Connection::SetSchemaVersion(int32_t aVersion) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + nsAutoCString stmt(NS_LITERAL_CSTRING("PRAGMA user_version = ")); + stmt.AppendInt(aVersion); + + return ExecuteSimpleSQL(stmt); +} + +NS_IMETHODIMP +Connection::CreateStatement(const nsACString &aSQLStatement, + mozIStorageStatement **_stmt) +{ + NS_ENSURE_ARG_POINTER(_stmt); + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + RefPtr<Statement> statement(new Statement()); + NS_ENSURE_TRUE(statement, NS_ERROR_OUT_OF_MEMORY); + + nsresult rv = statement->initialize(this, mDBConn, aSQLStatement); + NS_ENSURE_SUCCESS(rv, rv); + + Statement *rawPtr; + statement.forget(&rawPtr); + *_stmt = rawPtr; + return NS_OK; +} + +NS_IMETHODIMP +Connection::CreateAsyncStatement(const nsACString &aSQLStatement, + mozIStorageAsyncStatement **_stmt) +{ + NS_ENSURE_ARG_POINTER(_stmt); + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + RefPtr<AsyncStatement> statement(new AsyncStatement()); + NS_ENSURE_TRUE(statement, NS_ERROR_OUT_OF_MEMORY); + + nsresult rv = statement->initialize(this, mDBConn, aSQLStatement); + NS_ENSURE_SUCCESS(rv, rv); + + AsyncStatement *rawPtr; + statement.forget(&rawPtr); + *_stmt = rawPtr; + return NS_OK; +} + +NS_IMETHODIMP +Connection::ExecuteSimpleSQL(const nsACString &aSQLStatement) +{ + CHECK_MAINTHREAD_ABUSE(); + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + int srv = executeSql(mDBConn, PromiseFlatCString(aSQLStatement).get()); + return convertResultCode(srv); +} + +NS_IMETHODIMP +Connection::ExecuteAsync(mozIStorageBaseStatement **aStatements, + uint32_t aNumStatements, + mozIStorageStatementCallback *aCallback, + mozIStoragePendingStatement **_handle) +{ + nsTArray<StatementData> stmts(aNumStatements); + for (uint32_t i = 0; i < aNumStatements; i++) { + nsCOMPtr<StorageBaseStatementInternal> stmt = + do_QueryInterface(aStatements[i]); + + // Obtain our StatementData. + StatementData data; + nsresult rv = stmt->getAsynchronousStatementData(data); + NS_ENSURE_SUCCESS(rv, rv); + + NS_ASSERTION(stmt->getOwner() == this, + "Statement must be from this database connection!"); + + // Now append it to our array. + NS_ENSURE_TRUE(stmts.AppendElement(data), NS_ERROR_OUT_OF_MEMORY); + } + + // Dispatch to the background + return AsyncExecuteStatements::execute(stmts, this, mDBConn, aCallback, + _handle); +} + +NS_IMETHODIMP +Connection::ExecuteSimpleSQLAsync(const nsACString &aSQLStatement, + mozIStorageStatementCallback *aCallback, + mozIStoragePendingStatement **_handle) +{ + if (!NS_IsMainThread()) { + return NS_ERROR_NOT_SAME_THREAD; + } + + nsCOMPtr<mozIStorageAsyncStatement> stmt; + nsresult rv = CreateAsyncStatement(aSQLStatement, getter_AddRefs(stmt)); + if (NS_FAILED(rv)) { + return rv; + } + + nsCOMPtr<mozIStoragePendingStatement> pendingStatement; + rv = stmt->ExecuteAsync(aCallback, getter_AddRefs(pendingStatement)); + if (NS_FAILED(rv)) { + return rv; + } + + pendingStatement.forget(_handle); + return rv; +} + +NS_IMETHODIMP +Connection::TableExists(const nsACString &aTableName, + bool *_exists) +{ + return databaseElementExists(TABLE, aTableName, _exists); +} + +NS_IMETHODIMP +Connection::IndexExists(const nsACString &aIndexName, + bool* _exists) +{ + return databaseElementExists(INDEX, aIndexName, _exists); +} + +NS_IMETHODIMP +Connection::GetTransactionInProgress(bool *_inProgress) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + SQLiteMutexAutoLock lockedScope(sharedDBMutex); + *_inProgress = mTransactionInProgress; + return NS_OK; +} + +NS_IMETHODIMP +Connection::BeginTransaction() +{ + return BeginTransactionAs(mozIStorageConnection::TRANSACTION_DEFERRED); +} + +NS_IMETHODIMP +Connection::BeginTransactionAs(int32_t aTransactionType) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + return beginTransactionInternal(mDBConn, aTransactionType); +} + +nsresult +Connection::beginTransactionInternal(sqlite3 *aNativeConnection, + int32_t aTransactionType) +{ + SQLiteMutexAutoLock lockedScope(sharedDBMutex); + if (mTransactionInProgress) + return NS_ERROR_FAILURE; + nsresult rv; + switch(aTransactionType) { + case TRANSACTION_DEFERRED: + rv = convertResultCode(executeSql(aNativeConnection, "BEGIN DEFERRED")); + break; + case TRANSACTION_IMMEDIATE: + rv = convertResultCode(executeSql(aNativeConnection, "BEGIN IMMEDIATE")); + break; + case TRANSACTION_EXCLUSIVE: + rv = convertResultCode(executeSql(aNativeConnection, "BEGIN EXCLUSIVE")); + break; + default: + return NS_ERROR_ILLEGAL_VALUE; + } + if (NS_SUCCEEDED(rv)) + mTransactionInProgress = true; + return rv; +} + +NS_IMETHODIMP +Connection::CommitTransaction() +{ + if (!mDBConn) + return NS_ERROR_NOT_INITIALIZED; + + return commitTransactionInternal(mDBConn); +} + +nsresult +Connection::commitTransactionInternal(sqlite3 *aNativeConnection) +{ + SQLiteMutexAutoLock lockedScope(sharedDBMutex); + if (!mTransactionInProgress) + return NS_ERROR_UNEXPECTED; + nsresult rv = + convertResultCode(executeSql(aNativeConnection, "COMMIT TRANSACTION")); + if (NS_SUCCEEDED(rv)) + mTransactionInProgress = false; + return rv; +} + +NS_IMETHODIMP +Connection::RollbackTransaction() +{ + if (!mDBConn) + return NS_ERROR_NOT_INITIALIZED; + + return rollbackTransactionInternal(mDBConn); +} + +nsresult +Connection::rollbackTransactionInternal(sqlite3 *aNativeConnection) +{ + SQLiteMutexAutoLock lockedScope(sharedDBMutex); + if (!mTransactionInProgress) + return NS_ERROR_UNEXPECTED; + + nsresult rv = + convertResultCode(executeSql(aNativeConnection, "ROLLBACK TRANSACTION")); + if (NS_SUCCEEDED(rv)) + mTransactionInProgress = false; + return rv; +} + +NS_IMETHODIMP +Connection::CreateTable(const char *aTableName, + const char *aTableSchema) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + char *buf = ::PR_smprintf("CREATE TABLE %s (%s)", aTableName, aTableSchema); + if (!buf) + return NS_ERROR_OUT_OF_MEMORY; + + int srv = executeSql(mDBConn, buf); + ::PR_smprintf_free(buf); + + return convertResultCode(srv); +} + +NS_IMETHODIMP +Connection::CreateFunction(const nsACString &aFunctionName, + int32_t aNumArguments, + mozIStorageFunction *aFunction) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + // Check to see if this function is already defined. We only check the name + // because a function can be defined with the same body but different names. + SQLiteMutexAutoLock lockedScope(sharedDBMutex); + NS_ENSURE_FALSE(mFunctions.Get(aFunctionName, nullptr), NS_ERROR_FAILURE); + + int srv = ::sqlite3_create_function(mDBConn, + nsPromiseFlatCString(aFunctionName).get(), + aNumArguments, + SQLITE_ANY, + aFunction, + basicFunctionHelper, + nullptr, + nullptr); + if (srv != SQLITE_OK) + return convertResultCode(srv); + + FunctionInfo info = { aFunction, + Connection::FunctionInfo::SIMPLE, + aNumArguments }; + mFunctions.Put(aFunctionName, info); + + return NS_OK; +} + +NS_IMETHODIMP +Connection::CreateAggregateFunction(const nsACString &aFunctionName, + int32_t aNumArguments, + mozIStorageAggregateFunction *aFunction) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + // Check to see if this function name is already defined. + SQLiteMutexAutoLock lockedScope(sharedDBMutex); + NS_ENSURE_FALSE(mFunctions.Get(aFunctionName, nullptr), NS_ERROR_FAILURE); + + // Because aggregate functions depend on state across calls, you cannot have + // the same instance use the same name. We want to enumerate all functions + // and make sure this instance is not already registered. + NS_ENSURE_FALSE(findFunctionByInstance(aFunction), NS_ERROR_FAILURE); + + int srv = ::sqlite3_create_function(mDBConn, + nsPromiseFlatCString(aFunctionName).get(), + aNumArguments, + SQLITE_ANY, + aFunction, + nullptr, + aggregateFunctionStepHelper, + aggregateFunctionFinalHelper); + if (srv != SQLITE_OK) + return convertResultCode(srv); + + FunctionInfo info = { aFunction, + Connection::FunctionInfo::AGGREGATE, + aNumArguments }; + mFunctions.Put(aFunctionName, info); + + return NS_OK; +} + +NS_IMETHODIMP +Connection::RemoveFunction(const nsACString &aFunctionName) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + SQLiteMutexAutoLock lockedScope(sharedDBMutex); + NS_ENSURE_TRUE(mFunctions.Get(aFunctionName, nullptr), NS_ERROR_FAILURE); + + int srv = ::sqlite3_create_function(mDBConn, + nsPromiseFlatCString(aFunctionName).get(), + 0, + SQLITE_ANY, + nullptr, + nullptr, + nullptr, + nullptr); + if (srv != SQLITE_OK) + return convertResultCode(srv); + + mFunctions.Remove(aFunctionName); + + return NS_OK; +} + +NS_IMETHODIMP +Connection::SetProgressHandler(int32_t aGranularity, + mozIStorageProgressHandler *aHandler, + mozIStorageProgressHandler **_oldHandler) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + // Return previous one + SQLiteMutexAutoLock lockedScope(sharedDBMutex); + NS_IF_ADDREF(*_oldHandler = mProgressHandler); + + if (!aHandler || aGranularity <= 0) { + aHandler = nullptr; + aGranularity = 0; + } + mProgressHandler = aHandler; + ::sqlite3_progress_handler(mDBConn, aGranularity, sProgressHelper, this); + + return NS_OK; +} + +NS_IMETHODIMP +Connection::RemoveProgressHandler(mozIStorageProgressHandler **_oldHandler) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + // Return previous one + SQLiteMutexAutoLock lockedScope(sharedDBMutex); + NS_IF_ADDREF(*_oldHandler = mProgressHandler); + + mProgressHandler = nullptr; + ::sqlite3_progress_handler(mDBConn, 0, nullptr, nullptr); + + return NS_OK; +} + +NS_IMETHODIMP +Connection::SetGrowthIncrement(int32_t aChunkSize, const nsACString &aDatabaseName) +{ + // Bug 597215: Disk space is extremely limited on Android + // so don't preallocate space. This is also not effective + // on log structured file systems used by Android devices +#if !defined(ANDROID) && !defined(MOZ_PLATFORM_MAEMO) + // Don't preallocate if less than 500MiB is available. + int64_t bytesAvailable; + nsresult rv = mDatabaseFile->GetDiskSpaceAvailable(&bytesAvailable); + NS_ENSURE_SUCCESS(rv, rv); + if (bytesAvailable < MIN_AVAILABLE_BYTES_PER_CHUNKED_GROWTH) { + return NS_ERROR_FILE_TOO_BIG; + } + + (void)::sqlite3_file_control(mDBConn, + aDatabaseName.Length() ? nsPromiseFlatCString(aDatabaseName).get() + : nullptr, + SQLITE_FCNTL_CHUNK_SIZE, + &aChunkSize); +#endif + return NS_OK; +} + +NS_IMETHODIMP +Connection::EnableModule(const nsACString& aModuleName) +{ + if (!mDBConn) return NS_ERROR_NOT_INITIALIZED; + + for (size_t i = 0; i < ArrayLength(gModules); i++) { + struct Module* m = &gModules[i]; + if (aModuleName.Equals(m->name)) { + int srv = m->registerFunc(mDBConn, m->name); + if (srv != SQLITE_OK) + return convertResultCode(srv); + + return NS_OK; + } + } + + return NS_ERROR_FAILURE; +} + +// Implemented in TelemetryVFS.cpp +already_AddRefed<QuotaObject> +GetQuotaObjectForFile(sqlite3_file *pFile); + +NS_IMETHODIMP +Connection::GetQuotaObjects(QuotaObject** aDatabaseQuotaObject, + QuotaObject** aJournalQuotaObject) +{ + MOZ_ASSERT(aDatabaseQuotaObject); + MOZ_ASSERT(aJournalQuotaObject); + + if (!mDBConn) { + return NS_ERROR_NOT_INITIALIZED; + } + + sqlite3_file* file; + int srv = ::sqlite3_file_control(mDBConn, + nullptr, + SQLITE_FCNTL_FILE_POINTER, + &file); + if (srv != SQLITE_OK) { + return convertResultCode(srv); + } + + RefPtr<QuotaObject> databaseQuotaObject = GetQuotaObjectForFile(file); + + srv = ::sqlite3_file_control(mDBConn, + nullptr, + SQLITE_FCNTL_JOURNAL_POINTER, + &file); + if (srv != SQLITE_OK) { + return convertResultCode(srv); + } + + RefPtr<QuotaObject> journalQuotaObject = GetQuotaObjectForFile(file); + + databaseQuotaObject.forget(aDatabaseQuotaObject); + journalQuotaObject.forget(aJournalQuotaObject); + return NS_OK; +} + +} // namespace storage +} // namespace mozilla |