gecko-dev/storage/mozStorageBindingParams.cpp

529 строки
14 KiB
C++
Исходник Обычный вид История

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
2012-05-21 15:12:37 +04:00
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <limits.h>
#include "nsString.h"
#include "mozStorageError.h"
#include "mozStoragePrivateHelpers.h"
#include "mozStorageBindingParams.h"
#include "mozStorageBindingParamsArray.h"
#include "Variant.h"
namespace mozilla {
namespace storage {
////////////////////////////////////////////////////////////////////////////////
//// Local Helper Objects
namespace {
struct BindingColumnData
{
BindingColumnData(sqlite3_stmt *aStmt,
int aColumn)
: stmt(aStmt)
, column(aColumn)
{
}
sqlite3_stmt *stmt;
int column;
};
////////////////////////////////////////////////////////////////////////////////
//// Variant Specialization Functions (variantToSQLiteT)
int
sqlite3_T_int(BindingColumnData aData,
int aValue)
{
return ::sqlite3_bind_int(aData.stmt, aData.column + 1, aValue);
}
int
sqlite3_T_int64(BindingColumnData aData,
sqlite3_int64 aValue)
{
return ::sqlite3_bind_int64(aData.stmt, aData.column + 1, aValue);
}
int
sqlite3_T_double(BindingColumnData aData,
double aValue)
{
return ::sqlite3_bind_double(aData.stmt, aData.column + 1, aValue);
}
int
sqlite3_T_text(BindingColumnData aData,
const nsCString& aValue)
{
return ::sqlite3_bind_text(aData.stmt,
aData.column + 1,
aValue.get(),
aValue.Length(),
SQLITE_TRANSIENT);
}
int
sqlite3_T_text16(BindingColumnData aData,
const nsString& aValue)
{
return ::sqlite3_bind_text16(aData.stmt,
aData.column + 1,
aValue.get(),
aValue.Length() * 2, // Length in bytes!
SQLITE_TRANSIENT);
}
int
sqlite3_T_null(BindingColumnData aData)
{
return ::sqlite3_bind_null(aData.stmt, aData.column + 1);
}
int
sqlite3_T_blob(BindingColumnData aData,
const void *aBlob,
int aSize)
{
return ::sqlite3_bind_blob(aData.stmt, aData.column + 1, aBlob, aSize,
free);
}
#include "variantToSQLiteT_impl.h"
} // namespace
////////////////////////////////////////////////////////////////////////////////
//// BindingParams
BindingParams::BindingParams(mozIStorageBindingParamsArray *aOwningArray,
Statement *aOwningStatement)
: mLocked(false)
, mOwningArray(aOwningArray)
, mOwningStatement(aOwningStatement)
, mParamCount(0)
{
(void)mOwningStatement->GetParameterCount(&mParamCount);
mParameters.SetCapacity(mParamCount);
}
BindingParams::BindingParams(mozIStorageBindingParamsArray *aOwningArray)
: mLocked(false)
, mOwningArray(aOwningArray)
, mOwningStatement(nullptr)
, mParamCount(0)
{
}
AsyncBindingParams::AsyncBindingParams(
mozIStorageBindingParamsArray *aOwningArray
)
: BindingParams(aOwningArray)
{
}
void
BindingParams::lock()
{
NS_ASSERTION(mLocked == false, "Parameters have already been locked!");
mLocked = true;
// We no longer need to hold a reference to our statement or our owning array.
// The array owns us at this point, and it will own a reference to the
// statement.
mOwningStatement = nullptr;
mOwningArray = nullptr;
}
void
BindingParams::unlock(Statement *aOwningStatement)
{
NS_ASSERTION(mLocked == true, "Parameters were not yet locked!");
mLocked = false;
mOwningStatement = aOwningStatement;
}
const mozIStorageBindingParamsArray *
BindingParams::getOwner() const
{
return mOwningArray;
}
////////////////////////////////////////////////////////////////////////////////
//// nsISupports
NS_IMPL_ISUPPORTS(
BindingParams
, mozIStorageBindingParams
, IStorageBindingParamsInternal
)
////////////////////////////////////////////////////////////////////////////////
//// IStorageBindingParamsInternal
already_AddRefed<mozIStorageError>
BindingParams::bind(sqlite3_stmt *aStatement)
{
// Iterate through all of our stored data, and bind it.
for (size_t i = 0; i < mParameters.Length(); i++) {
int rc = variantToSQLiteT(BindingColumnData(aStatement, i), mParameters[i]);
if (rc != SQLITE_OK) {
// We had an error while trying to bind. Now we need to create an error
// object with the right message. Note that we special case
// SQLITE_MISMATCH, but otherwise get the message from SQLite.
const char *msg = "Could not covert nsIVariant to SQLite type.";
if (rc != SQLITE_MISMATCH)
msg = ::sqlite3_errmsg(::sqlite3_db_handle(aStatement));
nsCOMPtr<mozIStorageError> err(new Error(rc, msg));
return err.forget();
}
}
return nullptr;
}
already_AddRefed<mozIStorageError>
AsyncBindingParams::bind(sqlite3_stmt * aStatement)
{
// We should bind by index using the super-class if there is nothing in our
// hashtable.
if (!mNamedParameters.Count())
return BindingParams::bind(aStatement);
nsCOMPtr<mozIStorageError> err;
for (auto iter = mNamedParameters.Iter(); !iter.Done(); iter.Next()) {
const nsACString &key = iter.Key();
// We do not accept any forms of names other than ":name", but we need to
// add the colon for SQLite.
nsAutoCString name(":");
name.Append(key);
int oneIdx = ::sqlite3_bind_parameter_index(aStatement, name.get());
if (oneIdx == 0) {
nsAutoCString errMsg(key);
errMsg.AppendLiteral(" is not a valid named parameter.");
err = new Error(SQLITE_RANGE, errMsg.get());
break;
}
// XPCVariant's AddRef and Release are not thread-safe and so we must not
// do anything that would invoke them here on the async thread. As such we
// can't cram aValue into mParameters using ReplaceObjectAt so that
// we can freeload off of the BindingParams::Bind implementation.
int rc = variantToSQLiteT(BindingColumnData(aStatement, oneIdx - 1),
iter.UserData());
if (rc != SQLITE_OK) {
// We had an error while trying to bind. Now we need to create an error
// object with the right message. Note that we special case
// SQLITE_MISMATCH, but otherwise get the message from SQLite.
const char *msg = "Could not covert nsIVariant to SQLite type.";
if (rc != SQLITE_MISMATCH) {
msg = ::sqlite3_errmsg(::sqlite3_db_handle(aStatement));
}
err = new Error(rc, msg);
break;
}
}
return err.forget();
}
///////////////////////////////////////////////////////////////////////////////
//// mozIStorageBindingParams
NS_IMETHODIMP
BindingParams::BindByName(const nsACString &aName,
nsIVariant *aValue)
{
NS_ENSURE_FALSE(mLocked, NS_ERROR_UNEXPECTED);
// Get the column index that we need to store this at.
uint32_t index;
nsresult rv = mOwningStatement->GetParameterIndex(aName, &index);
NS_ENSURE_SUCCESS(rv, rv);
return BindByIndex(index, aValue);
}
NS_IMETHODIMP
AsyncBindingParams::BindByName(const nsACString &aName,
nsIVariant *aValue)
{
NS_ENSURE_FALSE(mLocked, NS_ERROR_UNEXPECTED);
Bug 1207245 - part 6 - rename nsRefPtr<T> to RefPtr<T>; r=ehsan; a=Tomcat The bulk of this commit was generated with a script, executed at the top level of a typical source code checkout. The only non-machine-generated part was modifying MFBT's moz.build to reflect the new naming. CLOSED TREE makes big refactorings like this a piece of cake. # The main substitution. find . -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.mm' -o -name '*.idl'| \ xargs perl -p -i -e ' s/nsRefPtr\.h/RefPtr\.h/g; # handle includes s/nsRefPtr ?</RefPtr</g; # handle declarations and variables ' # Handle a special friend declaration in gfx/layers/AtomicRefCountedWithFinalize.h. perl -p -i -e 's/::nsRefPtr;/::RefPtr;/' gfx/layers/AtomicRefCountedWithFinalize.h # Handle nsRefPtr.h itself, a couple places that define constructors # from nsRefPtr, and code generators specially. We do this here, rather # than indiscriminantly s/nsRefPtr/RefPtr/, because that would rename # things like nsRefPtrHashtable. perl -p -i -e 's/nsRefPtr/RefPtr/g' \ mfbt/nsRefPtr.h \ xpcom/glue/nsCOMPtr.h \ xpcom/base/OwningNonNull.h \ ipc/ipdl/ipdl/lower.py \ ipc/ipdl/ipdl/builtin.py \ dom/bindings/Codegen.py \ python/lldbutils/lldbutils/utils.py # In our indiscriminate substitution above, we renamed # nsRefPtrGetterAddRefs, the class behind getter_AddRefs. Fix that up. find . -name '*.cpp' -o -name '*.h' -o -name '*.idl' | \ xargs perl -p -i -e 's/nsRefPtrGetterAddRefs/RefPtrGetterAddRefs/g' if [ -d .git ]; then git mv mfbt/nsRefPtr.h mfbt/RefPtr.h else hg mv mfbt/nsRefPtr.h mfbt/RefPtr.h fi --HG-- rename : mfbt/nsRefPtr.h => mfbt/RefPtr.h
2015-10-18 08:24:48 +03:00
RefPtr<Variant_base> variant = convertVariantToStorageVariant(aValue);
if (!variant)
return NS_ERROR_UNEXPECTED;
mNamedParameters.Put(aName, variant);
return NS_OK;
}
NS_IMETHODIMP
BindingParams::BindUTF8StringByName(const nsACString &aName,
const nsACString &aValue)
{
nsCOMPtr<nsIVariant> value(new UTF8TextVariant(aValue));
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByName(aName, value);
}
NS_IMETHODIMP
BindingParams::BindStringByName(const nsACString &aName,
const nsAString &aValue)
{
nsCOMPtr<nsIVariant> value(new TextVariant(aValue));
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByName(aName, value);
}
NS_IMETHODIMP
BindingParams::BindDoubleByName(const nsACString &aName,
double aValue)
{
nsCOMPtr<nsIVariant> value(new FloatVariant(aValue));
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByName(aName, value);
}
NS_IMETHODIMP
BindingParams::BindInt32ByName(const nsACString &aName,
int32_t aValue)
{
nsCOMPtr<nsIVariant> value(new IntegerVariant(aValue));
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByName(aName, value);
}
NS_IMETHODIMP
BindingParams::BindInt64ByName(const nsACString &aName,
int64_t aValue)
{
nsCOMPtr<nsIVariant> value(new IntegerVariant(aValue));
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByName(aName, value);
}
NS_IMETHODIMP
BindingParams::BindNullByName(const nsACString &aName)
{
nsCOMPtr<nsIVariant> value(new NullVariant());
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByName(aName, value);
}
NS_IMETHODIMP
BindingParams::BindBlobByName(const nsACString &aName,
const uint8_t *aValue,
uint32_t aValueSize)
{
NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);
std::pair<const void *, int> data(
static_cast<const void *>(aValue),
int(aValueSize)
);
nsCOMPtr<nsIVariant> value(new BlobVariant(data));
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByName(aName, value);
}
NS_IMETHODIMP
BindingParams::BindStringAsBlobByName(const nsACString& aName,
const nsAString& aValue)
{
return DoBindStringAsBlobByName(this, aName, aValue);
}
NS_IMETHODIMP
BindingParams::BindUTF8StringAsBlobByName(const nsACString& aName,
const nsACString& aValue)
{
return DoBindStringAsBlobByName(this, aName, aValue);
}
NS_IMETHODIMP
BindingParams::BindAdoptedBlobByName(const nsACString &aName,
uint8_t *aValue,
uint32_t aValueSize)
{
NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);
std::pair<uint8_t *, int> data(
aValue,
int(aValueSize)
);
nsCOMPtr<nsIVariant> value(new AdoptedBlobVariant(data));
return BindByName(aName, value);
}
NS_IMETHODIMP
BindingParams::BindByIndex(uint32_t aIndex,
nsIVariant *aValue)
{
NS_ENSURE_FALSE(mLocked, NS_ERROR_UNEXPECTED);
ENSURE_INDEX_VALUE(aIndex, mParamCount);
// Store the variant for later use.
Bug 1207245 - part 6 - rename nsRefPtr<T> to RefPtr<T>; r=ehsan; a=Tomcat The bulk of this commit was generated with a script, executed at the top level of a typical source code checkout. The only non-machine-generated part was modifying MFBT's moz.build to reflect the new naming. CLOSED TREE makes big refactorings like this a piece of cake. # The main substitution. find . -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.mm' -o -name '*.idl'| \ xargs perl -p -i -e ' s/nsRefPtr\.h/RefPtr\.h/g; # handle includes s/nsRefPtr ?</RefPtr</g; # handle declarations and variables ' # Handle a special friend declaration in gfx/layers/AtomicRefCountedWithFinalize.h. perl -p -i -e 's/::nsRefPtr;/::RefPtr;/' gfx/layers/AtomicRefCountedWithFinalize.h # Handle nsRefPtr.h itself, a couple places that define constructors # from nsRefPtr, and code generators specially. We do this here, rather # than indiscriminantly s/nsRefPtr/RefPtr/, because that would rename # things like nsRefPtrHashtable. perl -p -i -e 's/nsRefPtr/RefPtr/g' \ mfbt/nsRefPtr.h \ xpcom/glue/nsCOMPtr.h \ xpcom/base/OwningNonNull.h \ ipc/ipdl/ipdl/lower.py \ ipc/ipdl/ipdl/builtin.py \ dom/bindings/Codegen.py \ python/lldbutils/lldbutils/utils.py # In our indiscriminate substitution above, we renamed # nsRefPtrGetterAddRefs, the class behind getter_AddRefs. Fix that up. find . -name '*.cpp' -o -name '*.h' -o -name '*.idl' | \ xargs perl -p -i -e 's/nsRefPtrGetterAddRefs/RefPtrGetterAddRefs/g' if [ -d .git ]; then git mv mfbt/nsRefPtr.h mfbt/RefPtr.h else hg mv mfbt/nsRefPtr.h mfbt/RefPtr.h fi --HG-- rename : mfbt/nsRefPtr.h => mfbt/RefPtr.h
2015-10-18 08:24:48 +03:00
RefPtr<Variant_base> variant = convertVariantToStorageVariant(aValue);
if (!variant)
return NS_ERROR_UNEXPECTED;
if (mParameters.Length() <= aIndex) {
(void)mParameters.SetLength(aIndex);
(void)mParameters.AppendElement(variant);
}
else {
NS_ENSURE_TRUE(mParameters.ReplaceElementAt(aIndex, variant),
NS_ERROR_OUT_OF_MEMORY);
}
return NS_OK;
}
NS_IMETHODIMP
AsyncBindingParams::BindByIndex(uint32_t aIndex,
nsIVariant *aValue)
{
NS_ENSURE_FALSE(mLocked, NS_ERROR_UNEXPECTED);
// In the asynchronous case we do not know how many parameters there are to
// bind to, so we cannot check the validity of aIndex.
Bug 1207245 - part 6 - rename nsRefPtr<T> to RefPtr<T>; r=ehsan; a=Tomcat The bulk of this commit was generated with a script, executed at the top level of a typical source code checkout. The only non-machine-generated part was modifying MFBT's moz.build to reflect the new naming. CLOSED TREE makes big refactorings like this a piece of cake. # The main substitution. find . -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.mm' -o -name '*.idl'| \ xargs perl -p -i -e ' s/nsRefPtr\.h/RefPtr\.h/g; # handle includes s/nsRefPtr ?</RefPtr</g; # handle declarations and variables ' # Handle a special friend declaration in gfx/layers/AtomicRefCountedWithFinalize.h. perl -p -i -e 's/::nsRefPtr;/::RefPtr;/' gfx/layers/AtomicRefCountedWithFinalize.h # Handle nsRefPtr.h itself, a couple places that define constructors # from nsRefPtr, and code generators specially. We do this here, rather # than indiscriminantly s/nsRefPtr/RefPtr/, because that would rename # things like nsRefPtrHashtable. perl -p -i -e 's/nsRefPtr/RefPtr/g' \ mfbt/nsRefPtr.h \ xpcom/glue/nsCOMPtr.h \ xpcom/base/OwningNonNull.h \ ipc/ipdl/ipdl/lower.py \ ipc/ipdl/ipdl/builtin.py \ dom/bindings/Codegen.py \ python/lldbutils/lldbutils/utils.py # In our indiscriminate substitution above, we renamed # nsRefPtrGetterAddRefs, the class behind getter_AddRefs. Fix that up. find . -name '*.cpp' -o -name '*.h' -o -name '*.idl' | \ xargs perl -p -i -e 's/nsRefPtrGetterAddRefs/RefPtrGetterAddRefs/g' if [ -d .git ]; then git mv mfbt/nsRefPtr.h mfbt/RefPtr.h else hg mv mfbt/nsRefPtr.h mfbt/RefPtr.h fi --HG-- rename : mfbt/nsRefPtr.h => mfbt/RefPtr.h
2015-10-18 08:24:48 +03:00
RefPtr<Variant_base> variant = convertVariantToStorageVariant(aValue);
if (!variant)
return NS_ERROR_UNEXPECTED;
if (mParameters.Length() <= aIndex) {
mParameters.SetLength(aIndex);
mParameters.AppendElement(variant);
}
else {
NS_ENSURE_TRUE(mParameters.ReplaceElementAt(aIndex, variant),
NS_ERROR_OUT_OF_MEMORY);
}
return NS_OK;
}
NS_IMETHODIMP
BindingParams::BindUTF8StringByIndex(uint32_t aIndex,
const nsACString &aValue)
{
nsCOMPtr<nsIVariant> value(new UTF8TextVariant(aValue));
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByIndex(aIndex, value);
}
NS_IMETHODIMP
BindingParams::BindStringByIndex(uint32_t aIndex,
const nsAString &aValue)
{
nsCOMPtr<nsIVariant> value(new TextVariant(aValue));
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByIndex(aIndex, value);
}
NS_IMETHODIMP
BindingParams::BindDoubleByIndex(uint32_t aIndex,
double aValue)
{
nsCOMPtr<nsIVariant> value(new FloatVariant(aValue));
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByIndex(aIndex, value);
}
NS_IMETHODIMP
BindingParams::BindInt32ByIndex(uint32_t aIndex,
int32_t aValue)
{
nsCOMPtr<nsIVariant> value(new IntegerVariant(aValue));
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByIndex(aIndex, value);
}
NS_IMETHODIMP
BindingParams::BindInt64ByIndex(uint32_t aIndex,
int64_t aValue)
{
nsCOMPtr<nsIVariant> value(new IntegerVariant(aValue));
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByIndex(aIndex, value);
}
NS_IMETHODIMP
BindingParams::BindNullByIndex(uint32_t aIndex)
{
nsCOMPtr<nsIVariant> value(new NullVariant());
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByIndex(aIndex, value);
}
NS_IMETHODIMP
BindingParams::BindBlobByIndex(uint32_t aIndex,
const uint8_t *aValue,
uint32_t aValueSize)
{
NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);
std::pair<const void *, int> data(
static_cast<const void *>(aValue),
int(aValueSize)
);
nsCOMPtr<nsIVariant> value(new BlobVariant(data));
NS_ENSURE_TRUE(value, NS_ERROR_OUT_OF_MEMORY);
return BindByIndex(aIndex, value);
}
NS_IMETHODIMP
BindingParams::BindStringAsBlobByIndex(uint32_t aIndex, const nsAString& aValue)
{
return DoBindStringAsBlobByIndex(this, aIndex, aValue);
}
NS_IMETHODIMP
BindingParams::BindUTF8StringAsBlobByIndex(uint32_t aIndex,
const nsACString& aValue)
{
return DoBindStringAsBlobByIndex(this, aIndex, aValue);
}
NS_IMETHODIMP
BindingParams::BindAdoptedBlobByIndex(uint32_t aIndex,
uint8_t *aValue,
uint32_t aValueSize)
{
NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);
std::pair<uint8_t *, int> data(
static_cast<uint8_t *>(aValue),
int(aValueSize)
);
nsCOMPtr<nsIVariant> value(new AdoptedBlobVariant(data));
return BindByIndex(aIndex, value);
}
} // namespace storage
} // namespace mozilla