gecko-dev/storage/mozStoragePrivateHelpers.cpp
2017-06-26 14:19:58 -07:00

279 lines
7.5 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 "sqlite3.h"
#include "jsfriendapi.h"
#include "nsPrintfCString.h"
#include "nsString.h"
#include "nsError.h"
#include "mozilla/Mutex.h"
#include "mozilla/CondVar.h"
#include "nsQueryObject.h"
#include "nsThreadUtils.h"
#include "nsJSUtils.h"
#include "Variant.h"
#include "mozStoragePrivateHelpers.h"
#include "mozIStorageStatement.h"
#include "mozIStorageCompletionCallback.h"
#include "mozIStorageBindingParams.h"
#include "mozilla/Logging.h"
extern mozilla::LazyLogModule gStorageLog;
namespace mozilla {
namespace storage {
nsresult
convertResultCode(int aSQLiteResultCode)
{
// Drop off the extended result bits of the result code.
int rc = aSQLiteResultCode & 0xFF;
switch (rc) {
case SQLITE_OK:
case SQLITE_ROW:
case SQLITE_DONE:
return NS_OK;
case SQLITE_CORRUPT:
case SQLITE_NOTADB:
return NS_ERROR_FILE_CORRUPTED;
case SQLITE_PERM:
case SQLITE_CANTOPEN:
return NS_ERROR_FILE_ACCESS_DENIED;
case SQLITE_BUSY:
return NS_ERROR_STORAGE_BUSY;
case SQLITE_LOCKED:
return NS_ERROR_FILE_IS_LOCKED;
case SQLITE_READONLY:
return NS_ERROR_FILE_READ_ONLY;
case SQLITE_IOERR:
return NS_ERROR_STORAGE_IOERR;
case SQLITE_FULL:
case SQLITE_TOOBIG:
return NS_ERROR_FILE_NO_DEVICE_SPACE;
case SQLITE_NOMEM:
return NS_ERROR_OUT_OF_MEMORY;
case SQLITE_MISUSE:
return NS_ERROR_UNEXPECTED;
case SQLITE_ABORT:
case SQLITE_INTERRUPT:
return NS_ERROR_ABORT;
case SQLITE_CONSTRAINT:
return NS_ERROR_STORAGE_CONSTRAINT;
}
// generic error
#ifdef DEBUG
nsAutoCString message;
message.AppendLiteral("SQLite returned error code ");
message.AppendInt(rc);
message.AppendLiteral(" , Storage will convert it to NS_ERROR_FAILURE");
NS_WARNING_ASSERTION(rc == SQLITE_ERROR, message.get());
#endif
return NS_ERROR_FAILURE;
}
void
checkAndLogStatementPerformance(sqlite3_stmt *aStatement)
{
// Check to see if the query performed sorting operations or not. If it
// did, it may need to be optimized!
int count = ::sqlite3_stmt_status(aStatement, SQLITE_STMTSTATUS_SORT, 1);
if (count <= 0)
return;
const char *sql = ::sqlite3_sql(aStatement);
// Check to see if this is marked to not warn
if (::strstr(sql, "/* do not warn (bug "))
return;
// CREATE INDEX always sorts (sorting is a necessary step in creating
// an index). So ignore the warning there.
if (::strstr(sql, "CREATE INDEX") || ::strstr(sql, "CREATE UNIQUE INDEX"))
return;
nsAutoCString message("Suboptimal indexes for the SQL statement ");
#ifdef MOZ_STORAGE_SORTWARNING_SQL_DUMP
message.Append('`');
message.Append(sql);
message.AppendLiteral("` [");
message.AppendInt(count);
message.AppendLiteral(" sort operation(s)]");
#else
nsPrintfCString address("0x%p", aStatement);
message.Append(address);
#endif
message.AppendLiteral(" (http://mzl.la/1FuID0j).");
NS_WARNING(message.get());
}
nsIVariant *
convertJSValToVariant(
JSContext *aCtx,
const JS::Value& aValue)
{
if (aValue.isInt32())
return new IntegerVariant(aValue.toInt32());
if (aValue.isDouble())
return new FloatVariant(aValue.toDouble());
if (aValue.isString()) {
nsAutoJSString value;
if (!value.init(aCtx, aValue.toString()))
return nullptr;
return new TextVariant(value);
}
if (aValue.isBoolean())
return new IntegerVariant(aValue.isTrue() ? 1 : 0);
if (aValue.isNull())
return new NullVariant();
if (aValue.isObject()) {
JS::Rooted<JSObject*> obj(aCtx, &aValue.toObject());
// We only support Date instances, all others fail.
bool valid;
if (!js::DateIsValid(aCtx, obj, &valid) || !valid)
return nullptr;
double msecd;
if (!js::DateGetMsecSinceEpoch(aCtx, obj, &msecd))
return nullptr;
msecd *= 1000.0;
int64_t msec = msecd;
return new IntegerVariant(msec);
}
return nullptr;
}
Variant_base *
convertVariantToStorageVariant(nsIVariant* aVariant)
{
RefPtr<Variant_base> variant = do_QueryObject(aVariant);
if (variant) {
// JS helpers already convert the JS representation to a Storage Variant,
// in such a case there's nothing left to do here, so just pass-through.
return variant;
}
if (!aVariant)
return new NullVariant();
uint16_t dataType;
nsresult rv = aVariant->GetDataType(&dataType);
NS_ENSURE_SUCCESS(rv, nullptr);
switch (dataType) {
case nsIDataType::VTYPE_BOOL:
case nsIDataType::VTYPE_INT8:
case nsIDataType::VTYPE_INT16:
case nsIDataType::VTYPE_INT32:
case nsIDataType::VTYPE_UINT8:
case nsIDataType::VTYPE_UINT16:
case nsIDataType::VTYPE_UINT32:
case nsIDataType::VTYPE_INT64:
case nsIDataType::VTYPE_UINT64: {
int64_t v;
rv = aVariant->GetAsInt64(&v);
NS_ENSURE_SUCCESS(rv, nullptr);
return new IntegerVariant(v);
}
case nsIDataType::VTYPE_FLOAT:
case nsIDataType::VTYPE_DOUBLE: {
double v;
rv = aVariant->GetAsDouble(&v);
NS_ENSURE_SUCCESS(rv, nullptr);
return new FloatVariant(v);
}
case nsIDataType::VTYPE_CHAR:
case nsIDataType::VTYPE_CHAR_STR:
case nsIDataType::VTYPE_STRING_SIZE_IS:
case nsIDataType::VTYPE_UTF8STRING:
case nsIDataType::VTYPE_CSTRING: {
nsCString v;
rv = aVariant->GetAsAUTF8String(v);
NS_ENSURE_SUCCESS(rv, nullptr);
return new UTF8TextVariant(v);
}
case nsIDataType::VTYPE_WCHAR:
case nsIDataType::VTYPE_DOMSTRING:
case nsIDataType::VTYPE_WCHAR_STR:
case nsIDataType::VTYPE_WSTRING_SIZE_IS:
case nsIDataType::VTYPE_ASTRING: {
nsString v;
rv = aVariant->GetAsAString(v);
NS_ENSURE_SUCCESS(rv, nullptr);
return new TextVariant(v);
}
case nsIDataType::VTYPE_ARRAY: {
uint16_t type;
nsIID iid;
uint32_t len;
void *rawArray;
// Note this copies the array data.
rv = aVariant->GetAsArray(&type, &iid, &len, &rawArray);
NS_ENSURE_SUCCESS(rv, nullptr);
if (type == nsIDataType::VTYPE_UINT8) {
std::pair<uint8_t *, int> v(static_cast<uint8_t *>(rawArray), len);
// Take ownership of the data avoiding a further copy.
return new AdoptedBlobVariant(v);
}
MOZ_FALLTHROUGH;
}
case nsIDataType::VTYPE_EMPTY:
case nsIDataType::VTYPE_EMPTY_ARRAY:
case nsIDataType::VTYPE_VOID:
return new NullVariant();
case nsIDataType::VTYPE_ID:
case nsIDataType::VTYPE_INTERFACE:
case nsIDataType::VTYPE_INTERFACE_IS:
default:
NS_WARNING("Unsupported variant type");
return nullptr;
}
return nullptr;
}
namespace {
class CallbackEvent : public Runnable
{
public:
explicit CallbackEvent(mozIStorageCompletionCallback* aCallback)
: Runnable("storage::CallbackEvent")
, mCallback(aCallback)
{
}
NS_IMETHOD Run() override
{
(void)mCallback->Complete(NS_OK, nullptr);
return NS_OK;
}
private:
nsCOMPtr<mozIStorageCompletionCallback> mCallback;
};
} // namespace
already_AddRefed<nsIRunnable>
newCompletionEvent(mozIStorageCompletionCallback *aCallback)
{
NS_ASSERTION(aCallback, "Passing a null callback is a no-no!");
nsCOMPtr<nsIRunnable> event = new CallbackEvent(aCallback);
return event.forget();
}
} // namespace storage
} // namespace mozilla