mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-15 06:15:43 +00:00
26a1ba5c14
Backed out changeset 84fb749698ab (bug 1323100) Backed out changeset d6d25e8bd001 (bug 1323100) Backed out changeset 1b0855bb0c38 (bug 1323100) Backed out changeset b6953e3f5739 (bug 1323100) Backed out changeset 5572f3b63215 (bug 1323100) Backed out changeset 12fb4c533659 (bug 1323100) Backed out changeset c36524e4e919 (bug 1323100) Backed out changeset 1e3b3eddbe26 (bug 1323100) Backed out changeset 061110f1ae12 (bug 1323100) Backed out changeset 413dbd31725b (bug 1323100) Backed out changeset 06550f7eca62 (bug 1323100) Backed out changeset 940933b13b36 (bug 1323100) Backed out changeset a6d75c1cd724 (bug 1323100) Backed out changeset 681cacbbaa3b (bug 1323100) Backed out changeset 3d53787293f6 (bug 1323100) Backed out changeset c0340dfe4766 (bug 1323100) Backed out changeset 9f554991549d (bug 1323100) Backed out changeset 757539e7039a (bug 1323100) Backed out changeset a3c9b45aa917 (bug 1323100) Backed out changeset 23d69df98a66 (bug 1323100) Backed out changeset 1297ded6a01d (bug 1323100) Backed out changeset f4235b97257f (bug 1323100) Backed out changeset 93419cb4f29f (bug 1323100) Backed out changeset 865d1b81c804 (bug 1323100) Backed out changeset 54acf4ef8e84 (bug 1323100) Backed out changeset 88d17bcd8205 (bug 1323100) Backed out changeset 0c466e5e8933 (bug 1323100)
2040 lines
60 KiB
C++
2040 lines
60 KiB
C++
/* -*- 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() override {
|
|
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() override {
|
|
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) {
|
|
static nsThreadPoolNaming naming;
|
|
nsresult rv = NS_NewNamedThread(naming.GetNextThreadName("mozStorage"),
|
|
getter_AddRefs(mAsyncExecutionThread));
|
|
if (NS_FAILED(rv)) {
|
|
NS_WARNING("Failed to create async thread.");
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
#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 (auto& pragma : pragmas) {
|
|
// Read-only connections just need cache_size and temp_store pragmas.
|
|
if (aReadOnly && ::strcmp(pragma, "cache_size") != 0 &&
|
|
::strcmp(pragma, "temp_store") != 0) {
|
|
continue;
|
|
}
|
|
|
|
nsAutoCString pragmaQuery("PRAGMA ");
|
|
pragmaQuery.Append(pragma);
|
|
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 (auto& gModule : gModules) {
|
|
struct Module* m = &gModule;
|
|
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
|