diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
commit | 36d22d82aa202bb199967e9512281e9a53db42c9 (patch) | |
tree | 105e8c98ddea1c1e4784a60a5a6410fa416be2de /storage/StorageBaseStatementInternal.h | |
parent | Initial commit. (diff) | |
download | firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip |
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'storage/StorageBaseStatementInternal.h')
-rw-r--r-- | storage/StorageBaseStatementInternal.h | 297 |
1 files changed, 297 insertions, 0 deletions
diff --git a/storage/StorageBaseStatementInternal.h b/storage/StorageBaseStatementInternal.h new file mode 100644 index 0000000000..685f0f79d0 --- /dev/null +++ b/storage/StorageBaseStatementInternal.h @@ -0,0 +1,297 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: sw=2 ts=2 sts=2 expandtab + * 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/. */ + +#ifndef mozilla_storage_StorageBaseStatementInternal_h_ +#define mozilla_storage_StorageBaseStatementInternal_h_ + +#include "nsISupports.h" +#include "nsCOMPtr.h" +#include "mozStorageHelper.h" + +struct sqlite3; +struct sqlite3_stmt; +class mozIStorageBindingParamsArray; +class mozIStorageBindingParams; +class mozIStorageStatementCallback; +class mozIStoragePendingStatement; + +namespace mozilla { +namespace storage { + +#define STORAGEBASESTATEMENTINTERNAL_IID \ + { \ + 0xd18856c9, 0xbf07, 0x4ae2, { \ + 0x94, 0x5b, 0x1a, 0xdd, 0x49, 0x19, 0x55, 0x2a \ + } \ + } + +class Connection; +class StatementData; + +class AsyncStatementFinalizer; + +/** + * Implementation-only interface and shared logix mix-in corresponding to + * mozIStorageBaseStatement. Both Statement and AsyncStatement inherit from + * this. The interface aspect makes them look the same to implementation innards + * that aren't publicly accessible. The mix-in avoids code duplication in + * common implementations of mozIStorageBaseStatement, albeit with some minor + * performance/space overhead because we have to use defines to officially + * implement the methods on Statement/AsyncStatement (and proxy to this base + * class.) + */ +class StorageBaseStatementInternal : public nsISupports { + public: + NS_DECLARE_STATIC_IID_ACCESSOR(STORAGEBASESTATEMENTINTERNAL_IID) + + /** + * @return the connection that this statement belongs to. + */ + Connection* getOwner() { return mDBConnection; } + + /** + * Return the asynchronous statement, creating it if required. + * + * This is for use by the asynchronous execution code for StatementData + * created by AsyncStatements. Statement internally uses this method to + * prepopulate StatementData with the sqlite3_stmt. + * + * @param[out] stmt + * The sqlite3_stmt for asynchronous use. + * @return The SQLite result code for creating the statement if created, + * SQLITE_OK if creation was not required. + */ + virtual int getAsyncStatement(sqlite3_stmt** _stmt) = 0; + + /** + * Obtains the StatementData needed for asynchronous execution. + * + * This is for use by Connection to retrieve StatementData from statements + * when executeAsync is invoked. + * + * @param[out] _data + * A reference to a StatementData object that will be populated + * upon successful execution of this method. + * @return NS_OK if we were able to assemble the data, failure otherwise. + */ + virtual nsresult getAsynchronousStatementData(StatementData& _data) = 0; + + /** + * Construct a new BindingParams to be owned by the provided binding params + * array. This method exists so that BindingParamsArray does not need + * factory logic to determine what type of BindingParams to instantiate. + * + * @param aOwner + * The binding params array to own the newly created binding params. + * @return The new mozIStorageBindingParams instance appropriate to the + * underlying statement type. + */ + virtual already_AddRefed<mozIStorageBindingParams> newBindingParams( + mozIStorageBindingParamsArray* aOwner) = 0; + + protected: // mix-in bits are protected + StorageBaseStatementInternal(); + + RefPtr<Connection> mDBConnection; + sqlite3* mNativeConnection; + + /** + * Our asynchronous statement. + * + * For Statement this is populated by the first invocation to + * getAsyncStatement. + * + * For AsyncStatement, this is null at creation time and initialized by the + * async thread when it calls getAsyncStatement the first time the statement + * is executed. (Or in the event of badly formed SQL, every time.) + */ + sqlite3_stmt* mAsyncStatement; + + /** + * Initiate asynchronous finalization by dispatching an event to the + * asynchronous thread to finalize mAsyncStatement. This acquires a reference + * to this statement and proxies it back to the connection's owning thread + * for release purposes. + * + * In the event the asynchronous thread is already gone or we otherwise fail + * to dispatch an event to it we failover to invoking internalAsyncFinalize + * directly. (That's what the asynchronous finalizer would have called.) + * + * @note You must not call this method from your destructor because its + * operation assumes we are still alive. Call internalAsyncFinalize + * directly in that case. + */ + void asyncFinalize(); + + /** + * Cleanup the async sqlite3_stmt stored in mAsyncStatement if it exists by + * attempting to dispatch to the asynchronous thread if available, finalizing + * on this thread if it is not. + * + * @note Call this from your destructor, call asyncFinalize otherwise. + */ + void destructorAsyncFinalize(); + + NS_IMETHOD NewBindingParamsArray(mozIStorageBindingParamsArray** _array); + NS_IMETHOD ExecuteAsync(mozIStorageStatementCallback* aCallback, + mozIStoragePendingStatement** _stmt); + NS_IMETHOD EscapeStringForLIKE(const nsAString& aValue, char16_t aEscapeChar, + nsAString& _escapedString); + NS_IMETHOD EscapeUTF8StringForLIKE(const nsACString& aValue, char aEscapeChar, + nsACString& _escapedString); + + // Needs access to internalAsyncFinalize + friend class AsyncStatementFinalizer; +}; + +NS_DEFINE_STATIC_IID_ACCESSOR(StorageBaseStatementInternal, + STORAGEBASESTATEMENTINTERNAL_IID) + +#define NS_DECL_STORAGEBASESTATEMENTINTERNAL \ + virtual Connection* getOwner(); \ + virtual int getAsyncStatement(sqlite3_stmt** _stmt) override; \ + virtual nsresult getAsynchronousStatementData(StatementData& _data) \ + override; \ + virtual already_AddRefed<mozIStorageBindingParams> newBindingParams( \ + mozIStorageBindingParamsArray* aOwner) override; + +/** + * Helper macro to implement the proxying implementations. Because we are + * implementing methods that are part of mozIStorageBaseStatement and the + * implementation classes already use NS_DECL_MOZISTORAGEBASESTATEMENT we don't + * need to provide declaration support. + */ +#define MIX_IMPL(_class, _optionalGuard, _method, _declArgs, _invokeArgs) \ + NS_IMETHODIMP _class::_method _declArgs { \ + _optionalGuard return StorageBaseStatementInternal::_method _invokeArgs; \ + } + +/** + * Define proxying implementation for the given _class. If a state invariant + * needs to be checked and an early return possibly performed, pass the clause + * to use as _optionalGuard. + */ +#define MIXIN_IMPL_STORAGEBASESTATEMENTINTERNAL(_class, _optionalGuard) \ + MIX_IMPL(_class, _optionalGuard, NewBindingParamsArray, \ + (mozIStorageBindingParamsArray * *_array), (_array)) \ + MIX_IMPL(_class, _optionalGuard, ExecuteAsync, \ + (mozIStorageStatementCallback * aCallback, \ + mozIStoragePendingStatement * *_stmt), \ + (aCallback, _stmt)) \ + MIX_IMPL(_class, _optionalGuard, EscapeStringForLIKE, \ + (const nsAString& aValue, char16_t aEscapeChar, \ + nsAString& _escapedString), \ + (aValue, aEscapeChar, _escapedString)) \ + MIX_IMPL(_class, _optionalGuard, EscapeUTF8StringForLIKE, \ + (const nsACString& aValue, char aEscapeChar, \ + nsACString& _escapedString), \ + (aValue, aEscapeChar, _escapedString)) + +/** + * Name-building helper for BIND_GEN_IMPL. + */ +#define BIND_NAME_CONCAT(_nameBit, _concatBit) Bind##_nameBit##_concatBit + +/** + * We have type-specific convenience methods for C++ implementations in + * two different forms; by index and by name. The following macro allows + * us to avoid having to define repetitive things by hand. + * + * Because of limitations of macros and our desire to avoid requiring special + * permutations for the null and blob cases (whose argument count varies), + * we require that the argument declarations and corresponding invocation + * usages are passed in. + * + * @param _class + * The class name. + * @param _guard + * The guard clause to inject. + * @param _declName + * The argument list (with parens) for the ByName variants. + * @param _declIndex + * The argument list (with parens) for the ByIndex variants. + * @param _invArgs + * The invocation argumment list. + */ +#define BIND_GEN_IMPL(_class, _guard, _name, _declName, _declIndex, _invArgs) \ + NS_IMETHODIMP _class::BIND_NAME_CONCAT(_name, ByName) _declName { \ + _guard mozIStorageBindingParams* params = getParams(); \ + NS_ENSURE_TRUE(params, NS_ERROR_OUT_OF_MEMORY); \ + return params->BIND_NAME_CONCAT(_name, ByName) _invArgs; \ + } \ + NS_IMETHODIMP _class::BIND_NAME_CONCAT(_name, ByIndex) _declIndex { \ + _guard mozIStorageBindingParams* params = getParams(); \ + NS_ENSURE_TRUE(params, NS_ERROR_OUT_OF_MEMORY); \ + return params->BIND_NAME_CONCAT(_name, ByIndex) _invArgs; \ + } + +/** + * Implement BindByName/BindByIndex for the given class. + * + * @param _class The class name. + * @param _optionalGuard The guard clause to inject. + */ +#define BIND_BASE_IMPLS(_class, _optionalGuard) \ + NS_IMETHODIMP _class::BindByName(const nsACString& aName, \ + nsIVariant* aValue) { \ + _optionalGuard mozIStorageBindingParams* params = getParams(); \ + NS_ENSURE_TRUE(params, NS_ERROR_OUT_OF_MEMORY); \ + return params->BindByName(aName, aValue); \ + } \ + NS_IMETHODIMP _class::BindByIndex(uint32_t aIndex, nsIVariant* aValue) { \ + _optionalGuard mozIStorageBindingParams* params = getParams(); \ + NS_ENSURE_TRUE(params, NS_ERROR_OUT_OF_MEMORY); \ + return params->BindByIndex(aIndex, aValue); \ + } + +/** + * Define the various Bind*ByIndex, Bind*ByName stubs that just end up proxying + * to the params object. + */ +#define BOILERPLATE_BIND_PROXIES(_class, _optionalGuard) \ + BIND_BASE_IMPLS(_class, _optionalGuard) \ + BIND_GEN_IMPL(_class, _optionalGuard, UTF8String, \ + (const nsACString& aWhere, const nsACString& aValue), \ + (uint32_t aWhere, const nsACString& aValue), (aWhere, aValue)) \ + BIND_GEN_IMPL(_class, _optionalGuard, String, \ + (const nsACString& aWhere, const nsAString& aValue), \ + (uint32_t aWhere, const nsAString& aValue), (aWhere, aValue)) \ + BIND_GEN_IMPL(_class, _optionalGuard, Double, \ + (const nsACString& aWhere, double aValue), \ + (uint32_t aWhere, double aValue), (aWhere, aValue)) \ + BIND_GEN_IMPL(_class, _optionalGuard, Int32, \ + (const nsACString& aWhere, int32_t aValue), \ + (uint32_t aWhere, int32_t aValue), (aWhere, aValue)) \ + BIND_GEN_IMPL(_class, _optionalGuard, Int64, \ + (const nsACString& aWhere, int64_t aValue), \ + (uint32_t aWhere, int64_t aValue), (aWhere, aValue)) \ + BIND_GEN_IMPL(_class, _optionalGuard, Null, (const nsACString& aWhere), \ + (uint32_t aWhere), (aWhere)) \ + BIND_GEN_IMPL( \ + _class, _optionalGuard, Blob, \ + (const nsACString& aWhere, const uint8_t* aValue, uint32_t aValueSize), \ + (uint32_t aWhere, const uint8_t* aValue, uint32_t aValueSize), \ + (aWhere, aValue, aValueSize)) \ + BIND_GEN_IMPL(_class, _optionalGuard, BlobArray, \ + (const nsACString& aWhere, const nsTArray<uint8_t>& aValue), \ + (uint32_t aWhere, const nsTArray<uint8_t>& aValue), \ + (aWhere, aValue)) \ + BIND_GEN_IMPL(_class, _optionalGuard, StringAsBlob, \ + (const nsACString& aWhere, const nsAString& aValue), \ + (uint32_t aWhere, const nsAString& aValue), (aWhere, aValue)) \ + BIND_GEN_IMPL(_class, _optionalGuard, UTF8StringAsBlob, \ + (const nsACString& aWhere, const nsACString& aValue), \ + (uint32_t aWhere, const nsACString& aValue), (aWhere, aValue)) \ + BIND_GEN_IMPL( \ + _class, _optionalGuard, AdoptedBlob, \ + (const nsACString& aWhere, uint8_t* aValue, uint32_t aValueSize), \ + (uint32_t aWhere, uint8_t * aValue, uint32_t aValueSize), \ + (aWhere, aValue, aValueSize)) + +} // namespace storage +} // namespace mozilla + +#endif // mozilla_storage_StorageBaseStatementInternal_h_ |