diff options
Diffstat (limited to 'src/bun.js/bindings/sqlite/JSSQLiteStatement.cpp')
| -rw-r--r-- | src/bun.js/bindings/sqlite/JSSQLiteStatement.cpp | 1719 |
1 files changed, 1719 insertions, 0 deletions
diff --git a/src/bun.js/bindings/sqlite/JSSQLiteStatement.cpp b/src/bun.js/bindings/sqlite/JSSQLiteStatement.cpp new file mode 100644 index 000000000..f083fe79a --- /dev/null +++ b/src/bun.js/bindings/sqlite/JSSQLiteStatement.cpp @@ -0,0 +1,1719 @@ +#include "root.h" + +#include "JSSQLiteStatement.h" +#include "JavaScriptCore/JSObjectInlines.h" +#include "wtf/text/ExternalStringImpl.h" + +#include "JavaScriptCore/FunctionPrototype.h" +#include "JavaScriptCore/HeapAnalyzer.h" + +#include "JavaScriptCore/JSDestructibleObjectHeapCellType.h" +#include "JavaScriptCore/SlotVisitorMacros.h" +#include "JavaScriptCore/ObjectConstructor.h" +#include "JavaScriptCore/SubspaceInlines.h" +#include "wtf/GetPtr.h" +#include "wtf/PointerPreparations.h" +#include "wtf/URL.h" +#include "JavaScriptCore/TypedArrayInlines.h" +#include "JavaScriptCore/PropertyNameArray.h" +#include "Buffer.h" +#include "GCDefferalContext.h" +#include "Buffer.h" + +#include <JavaScriptCore/DOMJITAbstractHeap.h> +#include "DOMJITIDLConvert.h" +#include "DOMJITIDLType.h" +#include "DOMJITIDLTypeFilter.h" +#include "DOMJITHelpers.h" +#include <JavaScriptCore/DFGAbstractHeap.h> + +/* ******************************************************************************** */ +// Lazy Load SQLite on macOS +// This seemed to be about 3% faster on macOS +// but it might be noise +// it's kind of hard to tell +// it should be strictly better though because +// instead of two pointers, one for DYLD_STUB$$ and one for the actual library +// we only call one pointer for the actual library +// and it means there's less work for DYLD to do on startup +// i.e. it shouldn't have any impact on startup time +#ifdef LAZY_LOAD_SQLITE +#include "lazy_sqlite3.h" +#else +static inline int lazyLoadSQLite() +{ + return 0; +} + +#endif +/* ******************************************************************************** */ + +static WTF::String sqliteString(const char* str) +{ + auto res = WTF::String::fromUTF8(str); + sqlite3_free((void*)str); + return res; +} + +static void sqlite_free_typed_array(void* ctx, void* buf) +{ + sqlite3_free((void*)buf); +} + +static int DEFAULT_SQLITE_FLAGS + = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE; +static unsigned int DEFAULT_SQLITE_PREPARE_FLAGS = SQLITE_PREPARE_PERSISTENT; +static int MAX_SQLITE_PREPARE_FLAG = SQLITE_PREPARE_PERSISTENT | SQLITE_PREPARE_NORMALIZE | SQLITE_PREPARE_NO_VTAB; + +static JSC_DECLARE_HOST_FUNCTION(jsSQLStatementPrepareStatementFunction); +static JSC_DECLARE_HOST_FUNCTION(jsSQLStatementExecuteFunction); +static JSC_DECLARE_HOST_FUNCTION(jsSQLStatementOpenStatementFunction); +static JSC_DECLARE_HOST_FUNCTION(jsSQLStatementIsInTransactionFunction); + +static JSC_DECLARE_HOST_FUNCTION(jsSQLStatementLoadExtensionFunction); + +static JSC_DECLARE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunction); +static JSC_DECLARE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionRun); +static JSC_DECLARE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionGet); +static JSC_DECLARE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionAll); +static JSC_DECLARE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionRows); + +static JSC_DECLARE_CUSTOM_GETTER(jsSqlStatementGetColumnNames); +static JSC_DECLARE_CUSTOM_GETTER(jsSqlStatementGetColumnCount); + +static JSC_DECLARE_HOST_FUNCTION(jsSQLStatementSerialize); +static JSC_DECLARE_HOST_FUNCTION(jsSQLStatementDeserialize); +static inline JSC::JSValue jsNumberFromSQLite(sqlite3_stmt* stmt, unsigned int i) +{ + int64_t num = sqlite3_column_int64(stmt, i); + return num > INT_MAX || num < INT_MIN ? JSC::jsDoubleNumber(static_cast<double>(num)) : JSC::jsNumber(static_cast<int>(num)); +} + +#define CHECK_THIS \ + if (UNLIKELY(!castedThis)) { \ + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected SQLStatement"_s)); \ + return JSValue::encode(jsUndefined()); \ + } + +#define DO_REBIND(param) \ + if (param.isObject()) { \ + JSC::JSValue reb = castedThis->rebind(lexicalGlobalObject, param, true); \ + if (UNLIKELY(!reb.isNumber())) { \ + return JSValue::encode(reb); /* this means an error */ \ + } \ + } else { \ + throwException(lexicalGlobalObject, scope, createTypeError(lexicalGlobalObject, "Expected object or array"_s)); \ + return JSValue::encode(jsUndefined()); \ + } + +#define CHECK_PREPARED \ + if (UNLIKELY(castedThis->stmt == nullptr || castedThis->version_db == nullptr)) { \ + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Statement has finalized"_s)); \ + return JSValue::encode(jsUndefined()); \ + } + +class VersionSqlite3 { +public: + explicit VersionSqlite3(sqlite3* db) + : db(db) + , version(0) + { + } + sqlite3* db; + std::atomic<uint64_t> version; +}; + +class SQLiteSingleton { +public: + Vector<VersionSqlite3*> databases; + Vector<std::atomic<uint64_t>> schema_versions; +}; + +static SQLiteSingleton* _instance = nullptr; + +static Vector<VersionSqlite3*>& databases() +{ + if (!_instance) { + _instance = new SQLiteSingleton(); + _instance->databases = Vector<VersionSqlite3*>(); + _instance->databases.reserveInitialCapacity(4); + _instance->schema_versions = Vector<std::atomic<uint64_t>>(); + } + + return _instance->databases; +} + +extern "C" void Bun__closeAllSQLiteDatabasesForTermination() +{ + if (!_instance) { + return; + } + auto& dbs = _instance->databases; + + for (auto& db : dbs) { + if (db->db) + sqlite3_close_v2(db->db); + } +} + +namespace WebCore { +using namespace JSC; + +class JSSQLiteStatement : public JSC::JSNonFinalObject { +public: + using Base = JSC::JSNonFinalObject; + static JSSQLiteStatement* create(JSC::Structure* structure, JSDOMGlobalObject* globalObject, sqlite3_stmt* stmt, VersionSqlite3* version_db) + { + JSSQLiteStatement* ptr = new (NotNull, JSC::allocateCell<JSSQLiteStatement>(globalObject->vm())) JSSQLiteStatement(structure, *globalObject, stmt, version_db); + ptr->finishCreation(globalObject->vm()); + return ptr; + } + static void destroy(JSC::JSCell*); + template<typename, SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm) + { + return WebCore::subspaceForImpl<JSSQLiteStatement, UseCustomHeapCellType::No>( + vm, + [](auto& spaces) { return spaces.m_clientSubspaceForJSSQLiteStatement.get(); }, + [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSQLiteStatement = std::forward<decltype(space)>(space); }, + [](auto& spaces) { return spaces.m_subspaceForJSSQLiteStatement.get(); }, + [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSQLiteStatement = std::forward<decltype(space)>(space); }); + } + DECLARE_VISIT_CHILDREN; + DECLARE_EXPORT_INFO; + template<typename Visitor> void visitAdditionalChildren(Visitor&); + template<typename Visitor> static void visitOutputConstraints(JSCell*, Visitor&); + + // static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&); + + JSC::JSValue rebind(JSGlobalObject* globalObject, JSC::JSValue values, bool clone); + static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype) + { + return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info()); + } + + bool need_update() { return version_db->version.load() != version; } + void update_version() { version = version_db->version.load(); } + + ~JSSQLiteStatement(); + + sqlite3_stmt* stmt; + VersionSqlite3* version_db; + uint64_t version; + bool hasExecuted = false; + std::unique_ptr<PropertyNameArray> columnNames; + mutable WriteBarrier<JSC::JSObject> _prototype; + mutable WriteBarrier<JSC::Structure> _structure; + +protected: + JSSQLiteStatement(JSC::Structure* structure, JSDOMGlobalObject& globalObject, sqlite3_stmt* stmt, VersionSqlite3* version_db) + : Base(globalObject.vm(), structure) + , stmt(stmt) + , version_db(version_db) + , columnNames(new PropertyNameArray(globalObject.vm(), PropertyNameMode::Strings, PrivateSymbolMode::Exclude)) + , _structure(globalObject.vm(), this, nullptr) + , _prototype(globalObject.vm(), this, nullptr) + { + } + + void finishCreation(JSC::VM&); +}; + +static void initializeColumnNames(JSC::JSGlobalObject* lexicalGlobalObject, JSSQLiteStatement* castedThis) +{ + if (!castedThis->hasExecuted) { + castedThis->hasExecuted = true; + } else { + // reinitialize column + castedThis->columnNames.reset(new PropertyNameArray( + castedThis->columnNames->vm(), + castedThis->columnNames->propertyNameMode(), + castedThis->columnNames->privateSymbolMode())); + } + castedThis->update_version(); + + JSC::VM& vm = lexicalGlobalObject->vm(); + + auto* stmt = castedThis->stmt; + + castedThis->_structure.clear(); + castedThis->_prototype.clear(); + + int count = sqlite3_column_count(stmt); + if (count == 0) + return; + + // Fast path: + if (count < 64) { + // 64 is the maximum we can preallocate here + // see https://github.com/oven-sh/bun/issues/987 + // also see https://github.com/oven-sh/bun/issues/1646 + auto& globalObject = *lexicalGlobalObject; + PropertyOffset offset; + auto columnNames = castedThis->columnNames.get(); + bool anyHoles = false; + for (int i = 0; i < count; i++) { + const char* name = sqlite3_column_name(stmt, i); + + if (name == nullptr) { + anyHoles = true; + break; + } + + size_t len = strlen(name); + if (len == 0) { + anyHoles = true; + break; + } + + columnNames->add(Identifier::fromString(vm, WTF::String::fromUTF8(name, len))); + } + + if (LIKELY(!anyHoles)) { + Structure* structure = globalObject.structureCache().emptyObjectStructureForPrototype(&globalObject, globalObject.objectPrototype(), columnNames->size()); + vm.writeBarrier(castedThis, structure); + + for (const auto& propertyName : *columnNames) { + structure = Structure::addPropertyTransition(vm, structure, propertyName, 0, offset); + } + castedThis->_structure.set(vm, castedThis, structure); + + // We are done. + return; + } else { + // If for any reason we do not have column names, disable the fast path. + columnNames->releaseData(); + castedThis->columnNames.reset(new PropertyNameArray( + castedThis->columnNames->vm(), + castedThis->columnNames->propertyNameMode(), + castedThis->columnNames->privateSymbolMode())); + } + } + + // Slow path: + + JSC::ObjectInitializationScope initializationScope(vm); + + // 64 is the maximum we can preallocate here + // see https://github.com/oven-sh/bun/issues/987 + JSC::JSObject* object = JSC::constructEmptyObject(lexicalGlobalObject, lexicalGlobalObject->objectPrototype(), std::min(count, 64)); + + for (int i = 0; i < count; i++) { + const char* name = sqlite3_column_name(stmt, i); + + if (name == nullptr) + break; + + size_t len = strlen(name); + if (len == 0) + break; + + auto wtfString = WTF::String::fromUTF8(name, len); + auto str = JSValue(jsString(vm, wtfString)); + auto key = str.toPropertyKey(lexicalGlobalObject); + JSC::JSValue primitive = JSC::jsUndefined(); + auto decl = sqlite3_column_decltype(stmt, i); + if (decl != nullptr) { + switch (decl[0]) { + case 'F': + case 'D': + case 'I': { + primitive = jsNumber(0); + break; + } + case 'V': + case 'T': { + primitive = jsEmptyString(vm); + break; + } + } + } + + object->putDirect(vm, key, primitive, 0); + castedThis->columnNames->add(key); + } + castedThis->_prototype.set(vm, castedThis, object); +} + +void JSSQLiteStatement::destroy(JSC::JSCell* cell) +{ + JSSQLiteStatement* thisObject = static_cast<JSSQLiteStatement*>(cell); + sqlite3_finalize(thisObject->stmt); + thisObject->stmt = nullptr; +} + +void JSSQLiteStatementConstructor::destroy(JSC::JSCell* cell) +{ +} + +static inline bool rebindValue(JSC::JSGlobalObject* lexicalGlobalObject, sqlite3_stmt* stmt, int i, JSC::JSValue value, JSC::ThrowScope& scope, bool clone) +{ +#define CHECK_BIND(param) \ + int result = param; \ + if (UNLIKELY(result != SQLITE_OK)) { \ + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errstr(result)))); \ + return false; \ + } + // only clone if necessary + // SQLite has a way to call a destructor + // but there doesn't seem to be a way to pass a pointer? + // we can't use it if there's no pointer to ref/unref + auto transientOrStatic = (void (*)(void*))(clone ? SQLITE_TRANSIENT : SQLITE_STATIC); + + if (value.isUndefinedOrNull()) { + CHECK_BIND(sqlite3_bind_null(stmt, i)); + } else if (value.isBoolean()) { + CHECK_BIND(sqlite3_bind_int(stmt, i, value.toBoolean(lexicalGlobalObject) ? 1 : 0)); + } else if (value.isAnyInt()) { + int64_t val = value.asAnyInt(); + if (val < INT_MIN || val > INT_MAX) { + CHECK_BIND(sqlite3_bind_int64(stmt, i, val)); + } else { + CHECK_BIND(sqlite3_bind_int(stmt, i, val)) + } + } else if (value.isNumber()) { + CHECK_BIND(sqlite3_bind_double(stmt, i, value.asDouble())) + } else if (value.isString()) { + auto* str = value.toStringOrNull(lexicalGlobalObject); + if (UNLIKELY(!str)) { + throwException(lexicalGlobalObject, scope, createTypeError(lexicalGlobalObject, "Expected string"_s)); + return false; + } + + auto roped = str->tryGetValue(lexicalGlobalObject); + if (UNLIKELY(!roped)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Out of memory :("_s)); + return false; + } + + if (roped.is8Bit() && roped.containsOnlyASCII()) { + CHECK_BIND(sqlite3_bind_text(stmt, i, reinterpret_cast<const char*>(roped.characters8()), roped.length(), transientOrStatic)); + } else if (!roped.is8Bit()) { + CHECK_BIND(sqlite3_bind_text16(stmt, i, roped.characters16(), roped.length() * 2, transientOrStatic)); + } else { + auto utf8 = roped.utf8(); + CHECK_BIND(sqlite3_bind_text(stmt, i, utf8.data(), utf8.length(), SQLITE_TRANSIENT)); + } + + } else if (UNLIKELY(value.isHeapBigInt())) { + CHECK_BIND(sqlite3_bind_int64(stmt, i, JSBigInt::toBigInt64(value))); + } else if (JSC::JSArrayBufferView* buffer = JSC::jsDynamicCast<JSC::JSArrayBufferView*>(value)) { + CHECK_BIND(sqlite3_bind_blob(stmt, i, buffer->vector(), buffer->byteLength(), transientOrStatic)); + } else { + throwException(lexicalGlobalObject, scope, createTypeError(lexicalGlobalObject, "Binding expected string, TypedArray, boolean, number, bigint or null"_s)); + return false; + } + + return true; +#undef CHECK_BIND +} + +// this function does the equivalent of +// Object.entries(obj) +// except without the intermediate array of arrays +static JSC::JSValue rebindObject(JSC::JSGlobalObject* globalObject, JSC::JSValue targetValue, JSC::ThrowScope& scope, sqlite3_stmt* stmt, bool clone) +{ + JSObject* target = targetValue.toObject(globalObject); + RETURN_IF_EXCEPTION(scope, {}); + JSC::VM& vm = globalObject->vm(); + PropertyNameArray properties(vm, PropertyNameMode::Strings, PrivateSymbolMode::Exclude); + target->methodTable()->getOwnPropertyNames(target, globalObject, properties, DontEnumPropertiesMode::Include); + RETURN_IF_EXCEPTION(scope, {}); + int count = 0; + + for (const auto& propertyName : properties) { + PropertySlot slot(target, PropertySlot::InternalMethodType::GetOwnProperty); + bool hasProperty = target->methodTable()->getOwnPropertySlot(target, globalObject, propertyName, slot); + RETURN_IF_EXCEPTION(scope, JSValue()); + if (!hasProperty) + continue; + if (slot.attributes() & PropertyAttribute::DontEnum) + continue; + + JSValue value; + if (LIKELY(!slot.isTaintedByOpaqueObject())) + value = slot.getValue(globalObject, propertyName); + else { + value = target->get(globalObject, propertyName); + RETURN_IF_EXCEPTION(scope, JSValue()); + } + + // Ensure this gets freed on scope clear + auto utf8 = WTF::String(propertyName.string()).utf8(); + + int index = sqlite3_bind_parameter_index(stmt, utf8.data()); + if (index == 0) { + throwException(globalObject, scope, createError(globalObject, "Unknown parameter \"" + propertyName.string() + "\""_s)); + return JSValue(); + } + + if (!rebindValue(globalObject, stmt, index, value, scope, clone)) + return JSValue(); + RETURN_IF_EXCEPTION(scope, {}); + count++; + } + + return jsNumber(count); +} + +static JSC::JSValue rebindStatement(JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSValue values, JSC::ThrowScope& scope, sqlite3_stmt* stmt, bool clone) +{ + sqlite3_clear_bindings(stmt); + JSC::JSArray* array = jsDynamicCast<JSC::JSArray*>(values); + int max = sqlite3_bind_parameter_count(stmt); + + if (!array) { + if (JSC::JSObject* object = values.getObject()) { + auto res = rebindObject(lexicalGlobalObject, object, scope, stmt, clone); + RETURN_IF_EXCEPTION(scope, {}); + return res; + } + + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected array"_s)); + return jsUndefined(); + } + + int count = array->length(); + + if (count == 0) { + return jsNumber(0); + } + + if (count != max) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected " + String::number(max) + " values, got " + String::number(count))); + return jsUndefined(); + } + + int i = 0; + for (; i < count; i++) { + JSC::JSValue value = array->getIndexQuickly(i); + rebindValue(lexicalGlobalObject, stmt, i + 1, value, scope, clone); + RETURN_IF_EXCEPTION(scope, {}); + } + + return jsNumber(i); +} + +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementSetCustomSQLite, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + JSC::VM& vm = lexicalGlobalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + + JSValue thisValue = callFrame->thisValue(); + JSSQLiteStatementConstructor* thisObject = jsDynamicCast<JSSQLiteStatementConstructor*>(thisValue.getObject()); + if (UNLIKELY(!thisObject)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected SQL"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + if (callFrame->argumentCount() < 1) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected 1 argument"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + JSC::JSValue sqliteStrValue = callFrame->argument(0); + if (UNLIKELY(!sqliteStrValue.isString())) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected SQLite path"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + +#ifdef LAZY_LOAD_SQLITE + if (sqlite3_handle) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "SQLite already loaded\nThis function can only be called before SQLite has been loaded and exactly once. SQLite auto-loads when the first time you open a Database."_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + sqlite3_lib_path = sqliteStrValue.toWTFString(lexicalGlobalObject).utf8().data(); + if (lazyLoadSQLite() == -1) { + sqlite3_handle = nullptr; + WTF::String msg = WTF::String::fromUTF8(dlerror()); + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, msg)); + return JSValue::encode(JSC::jsUndefined()); + } +#endif + + RELEASE_AND_RETURN(scope, JSValue::encode(JSC::jsBoolean(true))); +} + +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementDeserialize, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + JSC::VM& vm = lexicalGlobalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + + JSValue thisValue = callFrame->thisValue(); + JSSQLiteStatementConstructor* thisObject = jsDynamicCast<JSSQLiteStatementConstructor*>(thisValue.getObject()); + JSC::JSArrayBufferView* array = jsDynamicCast<JSC::JSArrayBufferView*>(callFrame->argument(0)); + unsigned int flags = SQLITE_DESERIALIZE_FREEONCLOSE | SQLITE_DESERIALIZE_RESIZEABLE; + JSC::EnsureStillAliveScope ensureAliveArray(array); + + if (callFrame->argumentCount() > 1 and callFrame->argument(1).toBoolean(lexicalGlobalObject)) { + flags |= SQLITE_DESERIALIZE_READONLY; + } + + if (UNLIKELY(!thisObject)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected SQL"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + if (callFrame->argumentCount() < 1) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected 1 argument"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + if (UNLIKELY(!array)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected Uint8Array or Buffer"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + if (UNLIKELY(array->isDetached())) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "TypedArray is detached"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + +#if LAZY_LOAD_SQLITE + if (UNLIKELY(lazyLoadSQLite() < 0)) { + WTF::String msg = WTF::String::fromUTF8(dlerror()); + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, msg)); + return JSValue::encode(JSC::jsUndefined()); + } +#endif + + size_t byteLength = array->byteLength(); + void* ptr = array->vector(); + if (UNLIKELY(ptr == nullptr || byteLength == 0)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "ArrayBuffer must not be empty"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + void* data = sqlite3_malloc64(byteLength); + if (UNLIKELY(data == nullptr)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Failed to allocate memory"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + if (byteLength) { + memcpy(data, ptr, byteLength); + } + + sqlite3* db = nullptr; + if (sqlite3_open_v2(":memory:", &db, DEFAULT_SQLITE_FLAGS, nullptr) != SQLITE_OK) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Failed to open SQLite"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + int status = sqlite3_db_config(db, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, NULL); + assert(status == SQLITE_OK); + status = sqlite3_db_config(db, SQLITE_DBCONFIG_DEFENSIVE, 1, NULL); + assert(status == SQLITE_OK); + + status = sqlite3_deserialize(db, "main", reinterpret_cast<unsigned char*>(data), byteLength, byteLength, flags); + if (status == SQLITE_BUSY) { + sqlite3_free(data); + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "SQLITE_BUSY"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + if (status != SQLITE_OK) { + sqlite3_free(data); + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, status == SQLITE_ERROR ? "unable to deserialize database"_s : sqliteString(sqlite3_errstr(status)))); + return JSValue::encode(JSC::jsUndefined()); + } + + auto count = databases().size(); + databases().append(new VersionSqlite3(db)); + RELEASE_AND_RETURN(scope, JSValue::encode(jsNumber(count))); +} + +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementSerialize, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + JSC::VM& vm = lexicalGlobalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + + JSValue thisValue = callFrame->thisValue(); + JSSQLiteStatementConstructor* thisObject = jsDynamicCast<JSSQLiteStatementConstructor*>(thisValue.getObject()); + if (UNLIKELY(!thisObject)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected SQL"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + int32_t dbIndex = callFrame->argument(0).toInt32(lexicalGlobalObject); + if (UNLIKELY(dbIndex < 0 || dbIndex >= databases().size())) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Invalid database handle"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + sqlite3* db = databases()[dbIndex]->db; + if (UNLIKELY(!db)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Can't do this on a closed database"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + WTF::String attachedName = callFrame->argument(1).toWTFString(lexicalGlobalObject); + RETURN_IF_EXCEPTION(scope, JSC::JSValue::encode(JSC::jsUndefined())); + + if (attachedName.isEmpty()) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected attached database name"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + sqlite3_int64 length = -1; + unsigned char* data = sqlite3_serialize(db, attachedName.utf8().data(), &length, 0); + if (UNLIKELY(data == nullptr && length)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Out of memory"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + RELEASE_AND_RETURN(scope, JSBuffer__bufferFromPointerAndLengthAndDeinit(lexicalGlobalObject, reinterpret_cast<char*>(data), static_cast<unsigned int>(length), data, sqlite_free_typed_array)); +} + +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementLoadExtensionFunction, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + JSC::VM& vm = lexicalGlobalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + + JSValue thisValue = callFrame->thisValue(); + JSSQLiteStatementConstructor* thisObject = jsDynamicCast<JSSQLiteStatementConstructor*>(thisValue.getObject()); + if (UNLIKELY(!thisObject)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected SQL"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + int32_t dbIndex = callFrame->argument(0).toInt32(lexicalGlobalObject); + if (UNLIKELY(dbIndex < 0 || dbIndex >= databases().size())) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Invalid database handle"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + JSC::JSValue extension = callFrame->argument(1); + if (UNLIKELY(!extension.isString())) { + throwException(lexicalGlobalObject, scope, createTypeError(lexicalGlobalObject, "Expected string"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + auto extensionString = extension.toWTFString(lexicalGlobalObject); + RETURN_IF_EXCEPTION(scope, {}); + + sqlite3* db = databases()[dbIndex]->db; + if (UNLIKELY(!db)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Can't do this on a closed database"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + if (sqlite3_compileoption_used("SQLITE_OMIT_LOAD_EXTENSION")) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "This build of sqlite3 does not support dynamic extension loading"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + auto entryPointStr = callFrame->argumentCount() > 2 && callFrame->argument(2).isString() ? callFrame->argument(2).toWTFString(lexicalGlobalObject) : String(); + const char* entryPoint = entryPointStr.length() == 0 ? NULL : entryPointStr.utf8().data(); + char* error; + int rc = sqlite3_load_extension(db, extensionString.utf8().data(), entryPoint, &error); + + // TODO: can we disable loading extensions after this? + if (rc != SQLITE_OK) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, sqliteString(error != nullptr ? error : sqlite3_errmsg(db)))); + return JSValue::encode(JSC::jsUndefined()); + } + + RELEASE_AND_RETURN(scope, JSValue::encode(JSC::jsUndefined())); +} + +// This runs a query one-off +// without the overhead of a long-lived statement object +// does not return anything +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementExecuteFunction, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + JSC::VM& vm = lexicalGlobalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + + JSValue thisValue = callFrame->thisValue(); + JSSQLiteStatementConstructor* thisObject = jsDynamicCast<JSSQLiteStatementConstructor*>(thisValue.getObject()); + if (UNLIKELY(!thisObject)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected SQL"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + if (callFrame->argumentCount() < 2) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected at least 2 arguments"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + int32_t handle = callFrame->argument(0).toInt32(lexicalGlobalObject); + if (databases().size() < handle) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Invalid database handle"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + sqlite3* db = databases()[handle]->db; + + if (UNLIKELY(!db)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Database has closed"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + JSC::JSValue sqlValue = callFrame->argument(1); + if (UNLIKELY(!sqlValue.isString())) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected SQL string"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + EnsureStillAliveScope bindingsAliveScope = callFrame->argumentCount() > 2 ? callFrame->argument(2) : jsUndefined(); + + auto sqlString = sqlValue.toWTFString(lexicalGlobalObject); + if (UNLIKELY(sqlString.length() == 0)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "SQL string mustn't be blank"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + // TODO: trim whitespace & newlines before sending + // we don't because webkit doesn't expose a function that makes this super + // easy without using unicode whitespace definition the + // StringPrototype.trim() implementation GC allocates a new JSString* and + // potentially re-allocates the string (not 100% sure if reallocates) so we + // can't use that here + sqlite3_stmt* statement = nullptr; + + int rc = SQLITE_OK; + if (sqlString.is8Bit()) { + rc = sqlite3_prepare_v3(db, reinterpret_cast<const char*>(sqlString.characters8()), sqlString.length(), 0, &statement, nullptr); + } else { + rc = sqlite3_prepare16_v3(db, sqlString.characters16(), sqlString.length() * 2, 0, &statement, nullptr); + } + + if (UNLIKELY(rc != SQLITE_OK || statement == nullptr)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, rc == SQLITE_OK ? "Query contained no valid SQL statement; likely empty query."_s : WTF::String::fromUTF8(sqlite3_errmsg(db)))); + // sqlite3 handles when the pointer is null + sqlite3_finalize(statement); + return JSValue::encode(JSC::jsUndefined()); + } + + if (!bindingsAliveScope.value().isUndefinedOrNull()) { + if (bindingsAliveScope.value().isObject()) { + JSC::JSValue reb = rebindStatement(lexicalGlobalObject, bindingsAliveScope.value(), scope, statement, false); + if (UNLIKELY(!reb.isNumber())) { + sqlite3_finalize(statement); + return JSValue::encode(reb); /* this means an error */ + } + } else { + throwException(lexicalGlobalObject, scope, createTypeError(lexicalGlobalObject, "Expected bindings to be an object or array"_s)); + sqlite3_finalize(statement); + return JSValue::encode(jsUndefined()); + } + } + + rc = sqlite3_step(statement); + if (!sqlite3_stmt_readonly(statement)) { + databases()[handle]->version++; + } + + while (rc == SQLITE_ROW) { + rc = sqlite3_step(statement); + } + + if (UNLIKELY(rc != SQLITE_DONE && rc != SQLITE_OK)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errstr(rc)))); + // we finalize after just incase something about error messages in + // sqlite depends on the existence of the most recent statement i don't + // think that's actually how this works - just being cautious + sqlite3_finalize(statement); + return JSValue::encode(JSC::jsUndefined()); + } + + sqlite3_finalize(statement); + return JSValue::encode(jsUndefined()); +} + +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementIsInTransactionFunction, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + JSC::VM& vm = lexicalGlobalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + + JSValue thisValue = callFrame->thisValue(); + JSSQLiteStatementConstructor* thisObject = jsDynamicCast<JSSQLiteStatementConstructor*>(thisValue.getObject()); + if (UNLIKELY(!thisObject)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected SQLStatement"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + JSC::JSValue dbNumber = callFrame->argument(0); + + if (!dbNumber.isNumber()) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Invalid database handle"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + int32_t handle = dbNumber.toInt32(lexicalGlobalObject); + + if (handle < 0 || handle > databases().size()) { + throwException(lexicalGlobalObject, scope, createRangeError(lexicalGlobalObject, "Invalid database handle"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + sqlite3* db = databases()[handle]->db; + + if (UNLIKELY(!db)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Database has closed"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + RELEASE_AND_RETURN(scope, JSValue::encode(jsBoolean(!sqlite3_get_autocommit(db)))); +} + +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementPrepareStatementFunction, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + JSC::VM& vm = lexicalGlobalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + + JSValue thisValue = callFrame->thisValue(); + JSSQLiteStatementConstructor* thisObject = jsDynamicCast<JSSQLiteStatementConstructor*>(thisValue.getObject()); + if (UNLIKELY(!thisObject)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected SQLStatement"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + JSC::JSValue dbNumber = callFrame->argument(0); + JSC::JSValue sqlValue = callFrame->argument(1); + JSC::JSValue bindings = callFrame->argument(2); + JSC::JSValue prepareFlagsValue = callFrame->argument(3); + + if (!dbNumber.isNumber() || !sqlValue.isString()) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "SQLStatement requires a number and a string"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + int32_t handle = dbNumber.toInt32(lexicalGlobalObject); + if (handle < 0 || handle > databases().size()) { + throwException(lexicalGlobalObject, scope, createRangeError(lexicalGlobalObject, "Invalid database handle"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + sqlite3* db = databases()[handle]->db; + if (!db) { + throwException(lexicalGlobalObject, scope, createRangeError(lexicalGlobalObject, "Cannot use a closed database"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + auto sqlString = sqlValue.toWTFString(lexicalGlobalObject); + if (!sqlString.length()) { + throwException(lexicalGlobalObject, scope, createRangeError(lexicalGlobalObject, "Invalid SQL statement"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + + unsigned int flags = DEFAULT_SQLITE_PREPARE_FLAGS; + if (prepareFlagsValue.isNumber()) { + + int prepareFlags = prepareFlagsValue.toInt32(lexicalGlobalObject); + if (prepareFlags < 0 || prepareFlags > MAX_SQLITE_PREPARE_FLAG) { + throwException(lexicalGlobalObject, scope, createRangeError(lexicalGlobalObject, "Invalid prepare flags"_s)); + return JSValue::encode(JSC::jsUndefined()); + } + flags = static_cast<unsigned int>(prepareFlags); + } + + sqlite3_stmt* statement = nullptr; + + int rc = SQLITE_OK; + if (sqlString.is8Bit()) { + rc = sqlite3_prepare_v3(db, reinterpret_cast<const char*>(sqlString.characters8()), sqlString.length(), flags, &statement, nullptr); + } else { + rc = sqlite3_prepare16_v3(db, sqlString.characters16(), sqlString.length() * 2, flags, &statement, nullptr); + } + + if (rc != SQLITE_OK) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errmsg(db)))); + return JSValue::encode(JSC::jsUndefined()); + } + + auto* structure = JSSQLiteStatement::createStructure(vm, lexicalGlobalObject, lexicalGlobalObject->objectPrototype()); + // auto* structure = JSSQLiteStatement::createStructure(vm, globalObject(), thisObject->getDirect(vm, vm.propertyNames->prototype)); + JSSQLiteStatement* sqlStatement = JSSQLiteStatement::create( + structure, reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject), statement, databases()[handle]); + if (bindings.isObject()) { + auto* castedThis = sqlStatement; + DO_REBIND(bindings) + } + return JSValue::encode(JSValue(sqlStatement)); +} + +JSSQLiteStatementConstructor* JSSQLiteStatementConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure) +{ + NativeExecutable* executable = vm.getHostFunction(jsSQLStatementPrepareStatementFunction, ImplementationVisibility::Public, callHostFunctionAsConstructor, String("SQLStatement"_s)); + JSSQLiteStatementConstructor* ptr = new (NotNull, JSC::allocateCell<JSSQLiteStatementConstructor>(vm)) JSSQLiteStatementConstructor(vm, executable, globalObject, structure); + ptr->finishCreation(vm); + + return ptr; +} + +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementOpenStatementFunction, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + JSC::VM& vm = lexicalGlobalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + + JSValue thisValue = callFrame->thisValue(); + JSSQLiteStatementConstructor* constructor = jsDynamicCast<JSSQLiteStatementConstructor*>(thisValue.getObject()); + if (!constructor) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected SQLStatement"_s)); + return JSValue::encode(jsUndefined()); + } + + if (callFrame->argumentCount() < 1) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected 1 argument"_s)); + return JSValue::encode(jsUndefined()); + } + + JSValue pathValue = callFrame->argument(0); + if (!pathValue.isString()) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected string"_s)); + return JSValue::encode(jsUndefined()); + } + +#if LAZY_LOAD_SQLITE + if (UNLIKELY(lazyLoadSQLite() < 0)) { + WTF::String msg = WTF::String::fromUTF8(dlerror()); + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, msg)); + return JSValue::encode(JSC::jsUndefined()); + } +#endif + + auto catchScope = DECLARE_CATCH_SCOPE(vm); + String path = pathValue.toWTFString(lexicalGlobalObject); + RETURN_IF_EXCEPTION(catchScope, JSValue::encode(jsUndefined())); + catchScope.clearException(); + int openFlags = DEFAULT_SQLITE_FLAGS; + if (callFrame->argumentCount() > 1) { + JSValue flags = callFrame->argument(1); + if (!flags.isNumber()) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected number"_s)); + return JSValue::encode(jsUndefined()); + } + + openFlags = flags.toInt32(lexicalGlobalObject); + } + + sqlite3* db = nullptr; + int statusCode = sqlite3_open_v2(path.utf8().data(), &db, openFlags, nullptr); + if (statusCode != SQLITE_OK) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errmsg(db)))); + + return JSValue::encode(jsUndefined()); + } + + int status = sqlite3_db_config(db, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, NULL); + assert(status == SQLITE_OK); + status = sqlite3_db_config(db, SQLITE_DBCONFIG_DEFENSIVE, 1, NULL); + assert(status == SQLITE_OK); + + auto count = databases().size(); + databases().append(new VersionSqlite3(db)); + RELEASE_AND_RETURN(scope, JSValue::encode(jsNumber(count))); +} + +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementCloseStatementFunction, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + + JSC::VM& vm = lexicalGlobalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + + JSValue thisValue = callFrame->thisValue(); + JSSQLiteStatementConstructor* constructor = jsDynamicCast<JSSQLiteStatementConstructor*>(thisValue.getObject()); + + if (!constructor) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected SQLStatement"_s)); + return JSValue::encode(jsUndefined()); + } + + if (callFrame->argumentCount() < 1) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected 1 argument"_s)); + return JSValue::encode(jsUndefined()); + } + + JSValue dbNumber = callFrame->argument(0); + if (!dbNumber.isNumber()) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Expected number"_s)); + return JSValue::encode(jsUndefined()); + } + + int dbIndex = dbNumber.toInt32(lexicalGlobalObject); + + if (dbIndex < 0 || dbIndex >= databases().size()) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, "Invalid database handle"_s)); + return JSValue::encode(jsUndefined()); + } + + sqlite3* db = databases()[dbIndex]->db; + // no-op if already closed + if (!db) { + return JSValue::encode(jsUndefined()); + } + + int statusCode = sqlite3_close_v2(db); + if (statusCode != SQLITE_OK) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errmsg(db)))); + return JSValue::encode(jsUndefined()); + } + + databases()[dbIndex]->db = nullptr; + return JSValue::encode(jsUndefined()); +} + +/* Hash table for constructor */ +static const HashTableValue JSSQLiteStatementConstructorTableValues[] = { + { "open"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementOpenStatementFunction, 2 } }, + { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementCloseStatementFunction, 1 } }, + { "prepare"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementPrepareStatementFunction, 2 } }, + { "run"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementExecuteFunction, 3 } }, + { "isInTransaction"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementIsInTransactionFunction, 1 } }, + { "loadExtension"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementLoadExtensionFunction, 2 } }, + { "setCustomSQLite"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementSetCustomSQLite, 1 } }, + { "serialize"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementSerialize, 1 } }, + { "deserialize"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementDeserialize, 2 } }, +}; + +const ClassInfo JSSQLiteStatementConstructor::s_info = { "SQLStatement"_s, nullptr, nullptr, nullptr, CREATE_METHOD_TABLE(JSSQLiteStatementConstructor) }; + +void JSSQLiteStatementConstructor::finishCreation(VM& vm) +{ + Base::finishCreation(vm); + auto* structure = JSSQLiteStatement::createStructure(vm, globalObject(), globalObject()->objectPrototype()); + auto* proto = JSSQLiteStatement::create(structure, reinterpret_cast<Zig::GlobalObject*>(globalObject()), nullptr, nullptr); + this->putDirect(vm, vm.propertyNames->prototype, proto, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly); + + reifyStaticProperties(vm, JSSQLiteStatementConstructor::info(), JSSQLiteStatementConstructorTableValues, *this); + JSC_TO_STRING_TAG_WITHOUT_TRANSITION(); +} + +static inline JSC::JSValue constructResultObject(JSC::JSGlobalObject* lexicalGlobalObject, JSSQLiteStatement* castedThis); +static inline JSC::JSValue constructResultObject(JSC::JSGlobalObject* lexicalGlobalObject, JSSQLiteStatement* castedThis) +{ + auto& columnNames = castedThis->columnNames->data()->propertyNameVector(); + int count = columnNames.size(); + auto& vm = lexicalGlobalObject->vm(); + + // 64 is the maximum we can preallocate here + // see https://github.com/oven-sh/bun/issues/987 + JSC::JSObject* result; + + auto* stmt = castedThis->stmt; + + if (auto* structure = castedThis->_structure.get()) { + result = JSC::constructEmptyObject(vm, structure); + + for (unsigned int i = 0; i < count; i++) { + JSValue value; + + // Loop 1. Fill the rowBuffer with values from SQLite + switch (sqlite3_column_type(stmt, i)) { + case SQLITE_INTEGER: { + // https://github.com/oven-sh/bun/issues/1536 + value = jsNumberFromSQLite(stmt, i); + break; + } + case SQLITE_FLOAT: { + value = jsNumber(sqlite3_column_double(stmt, i)); + break; + } + // > Note that the SQLITE_TEXT constant was also used in SQLite version + // > 2 for a completely different meaning. Software that links against + // > both SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, + // > not SQLITE_TEXT. + case SQLITE3_TEXT: { + size_t len = sqlite3_column_bytes(stmt, i); + const unsigned char* text = len > 0 ? sqlite3_column_text(stmt, i) : nullptr; + + if (len > 64) { + value = JSC::JSValue::decode(Bun__encoding__toStringUTF8(text, len, lexicalGlobalObject)); + break; + } else { + value = jsString(vm, WTF::String::fromUTF8(text, len)); + break; + } + } + case SQLITE_BLOB: { + size_t len = sqlite3_column_bytes(stmt, i); + const void* blob = len > 0 ? sqlite3_column_blob(stmt, i) : nullptr; + JSC::JSUint8Array* array = JSC::JSUint8Array::createUninitialized(lexicalGlobalObject, lexicalGlobalObject->m_typedArrayUint8.get(lexicalGlobalObject), len); + + if (LIKELY(blob && len)) + memcpy(array->vector(), blob, len); + + value = array; + break; + } + default: { + value = jsNull(); + break; + } + } + + result->putDirectOffset(vm, i, value); + } + + } else { + if (count <= 64) { + result = JSC::JSFinalObject::create(vm, castedThis->_prototype.get()->structure()); + } else { + result = JSC::JSFinalObject::create(vm, JSC::JSFinalObject::createStructure(vm, lexicalGlobalObject, lexicalGlobalObject->objectPrototype(), std::min(count, 64))); + } + + for (int i = 0; i < count; i++) { + auto name = columnNames[i]; + + switch (sqlite3_column_type(stmt, i)) { + case SQLITE_INTEGER: { + // https://github.com/oven-sh/bun/issues/1536 + result->putDirect(vm, name, jsNumberFromSQLite(stmt, i), 0); + break; + } + case SQLITE_FLOAT: { + result->putDirect(vm, name, jsDoubleNumber(sqlite3_column_double(stmt, i)), 0); + break; + } + // > Note that the SQLITE_TEXT constant was also used in SQLite version + // > 2 for a completely different meaning. Software that links against + // > both SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, + // > not SQLITE_TEXT. + case SQLITE3_TEXT: { + size_t len = sqlite3_column_bytes(stmt, i); + const unsigned char* text = len > 0 ? sqlite3_column_text(stmt, i) : nullptr; + + if (len > 64) { + result->putDirect(vm, name, JSC::JSValue::decode(Bun__encoding__toStringUTF8(text, len, lexicalGlobalObject)), 0); + continue; + } + + result->putDirect(vm, name, jsString(vm, WTF::String::fromUTF8(text, len)), 0); + break; + } + case SQLITE_BLOB: { + size_t len = sqlite3_column_bytes(stmt, i); + const void* blob = len > 0 ? sqlite3_column_blob(stmt, i) : nullptr; + JSC::JSUint8Array* array = JSC::JSUint8Array::createUninitialized(lexicalGlobalObject, lexicalGlobalObject->m_typedArrayUint8.get(lexicalGlobalObject), len); + + if (LIKELY(blob && len)) + memcpy(array->vector(), blob, len); + + result->putDirect(vm, name, array, 0); + break; + } + default: { + result->putDirect(vm, name, jsNull(), 0); + break; + } + } + } + } + + return JSValue(result); +} + +static inline JSC::JSArray* constructResultRow(JSC::JSGlobalObject* lexicalGlobalObject, JSSQLiteStatement* castedThis, ObjectInitializationScope& scope, JSC::GCDeferralContext* deferralContext); +static inline JSC::JSArray* constructResultRow(JSC::JSGlobalObject* lexicalGlobalObject, JSSQLiteStatement* castedThis, ObjectInitializationScope& scope, JSC::GCDeferralContext* deferralContext) +{ + int count = castedThis->columnNames->size(); + auto& vm = lexicalGlobalObject->vm(); + + JSC::JSArray* result = JSArray::create(vm, lexicalGlobalObject->arrayStructureForIndexingTypeDuringAllocation(ArrayWithContiguous), count); + auto* stmt = castedThis->stmt; + + for (int i = 0; i < count; i++) { + + switch (sqlite3_column_type(stmt, i)) { + case SQLITE_INTEGER: { + // https://github.com/oven-sh/bun/issues/1536 + result->putDirectIndex(lexicalGlobalObject, i, jsNumberFromSQLite(stmt, i)); + break; + } + case SQLITE_FLOAT: { + result->putDirectIndex(lexicalGlobalObject, i, jsDoubleNumber(sqlite3_column_double(stmt, i))); + break; + } + // > Note that the SQLITE_TEXT constant was also used in SQLite version + // > 2 for a completely different meaning. Software that links against + // > both SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, + // > not SQLITE_TEXT. + case SQLITE_TEXT: { + size_t len = sqlite3_column_bytes(stmt, i); + const unsigned char* text = len > 0 ? sqlite3_column_text(stmt, i) : nullptr; + if (UNLIKELY(text == nullptr || len == 0)) { + result->putDirectIndex(lexicalGlobalObject, i, jsEmptyString(vm)); + continue; + } + result->putDirectIndex(lexicalGlobalObject, i, len < 64 ? jsString(vm, WTF::String::fromUTF8(text, len)) : JSC::JSValue::decode(Bun__encoding__toStringUTF8(text, len, lexicalGlobalObject))); + break; + } + case SQLITE_BLOB: { + size_t len = sqlite3_column_bytes(stmt, i); + const void* blob = len > 0 ? sqlite3_column_blob(stmt, i) : nullptr; + JSC::JSUint8Array* array = JSC::JSUint8Array::createUninitialized(lexicalGlobalObject, lexicalGlobalObject->m_typedArrayUint8.get(lexicalGlobalObject), len); + memcpy(array->vector(), blob, len); + result->putDirectIndex(lexicalGlobalObject, i, array); + break; + } + default: { + result->putDirectIndex(lexicalGlobalObject, i, jsNull()); + break; + } + } + } + + return result; +} + +static inline JSC::JSArray* constructResultRow(JSC::JSGlobalObject* lexicalGlobalObject, JSSQLiteStatement* castedThis, ObjectInitializationScope& scope) +{ + return constructResultRow(lexicalGlobalObject, castedThis, scope, nullptr); +} + +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionAll, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + + JSC::VM& vm = lexicalGlobalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + auto castedThis = jsDynamicCast<JSSQLiteStatement*>(callFrame->thisValue()); + + CHECK_THIS + + auto* stmt = castedThis->stmt; + CHECK_PREPARED + int statusCode = sqlite3_reset(stmt); + + if (UNLIKELY(statusCode != SQLITE_OK)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errstr(statusCode)))); + return JSValue::encode(jsUndefined()); + } + + if (callFrame->argumentCount() > 0) { + auto arg0 = callFrame->argument(0); + DO_REBIND(arg0); + } + + int status = sqlite3_step(stmt); + if (!sqlite3_stmt_readonly(stmt)) { + castedThis->version_db->version++; + } + + if (!castedThis->hasExecuted || castedThis->need_update()) { + initializeColumnNames(lexicalGlobalObject, castedThis); + } + + size_t columnCount = castedThis->columnNames->size(); + JSValue result = jsUndefined(); + + if (status == SQLITE_ROW) { + // this is a count from UPDATE or another query like that + if (columnCount == 0) { + result = jsNumber(sqlite3_changes(castedThis->version_db->db)); + + while (status == SQLITE_ROW) { + status = sqlite3_step(stmt); + } + } else { + + JSC::JSArray* resultArray = JSC::constructEmptyArray(lexicalGlobalObject, nullptr, 0); + { + while (status == SQLITE_ROW) { + JSC::JSValue result = constructResultObject(lexicalGlobalObject, castedThis); + resultArray->push(lexicalGlobalObject, result); + status = sqlite3_step(stmt); + } + } + result = resultArray; + } + } else if (status == SQLITE_DONE) { + if (columnCount == 0) { + result = jsNumber(sqlite3_changes(castedThis->version_db->db)); + } else { + result = JSC::constructEmptyArray(lexicalGlobalObject, nullptr, 0); + } + } + + if (UNLIKELY(status != SQLITE_DONE && status != SQLITE_OK)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errstr(status)))); + sqlite3_reset(stmt); + return JSValue::encode(jsUndefined()); + } + + RELEASE_AND_RETURN(scope, JSC::JSValue::encode(result)); +} + +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionGet, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + + JSC::VM& vm = lexicalGlobalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + auto castedThis = jsDynamicCast<JSSQLiteStatement*>(callFrame->thisValue()); + + CHECK_THIS + + auto* stmt = castedThis->stmt; + CHECK_PREPARED + + int statusCode = sqlite3_reset(stmt); + if (UNLIKELY(statusCode != SQLITE_OK)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errstr(statusCode)))); + return JSValue::encode(jsUndefined()); + } + + if (callFrame->argumentCount() > 0) { + auto arg0 = callFrame->argument(0); + DO_REBIND(arg0); + } + + int status = sqlite3_step(stmt); + if (!sqlite3_stmt_readonly(stmt)) { + castedThis->version_db->version++; + } + + if (!castedThis->hasExecuted || castedThis->need_update()) { + initializeColumnNames(lexicalGlobalObject, castedThis); + } + + JSValue result = jsNull(); + if (status == SQLITE_ROW) { + result = constructResultObject(lexicalGlobalObject, castedThis); + while (status == SQLITE_ROW) { + status = sqlite3_step(stmt); + } + } + + if (status == SQLITE_DONE || status == SQLITE_OK) { + RELEASE_AND_RETURN(scope, JSValue::encode(result)); + } else { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errstr(status)))); + sqlite3_reset(stmt); + return JSValue::encode(jsUndefined()); + } +} + +extern "C" { +static JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(jsSQLStatementExecuteStatementFunctionGetWithoutTypeChecking, JSC::EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, JSSQLiteStatement* castedThis)); +} + +JSC_DEFINE_JIT_OPERATION(jsSQLStatementExecuteStatementFunctionGetWithoutTypeChecking, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, JSSQLiteStatement* castedThis)) +{ + VM& vm = JSC::getVM(lexicalGlobalObject); + IGNORE_WARNINGS_BEGIN("frame-address") + CallFrame* callFrame = DECLARE_CALL_FRAME(vm); + IGNORE_WARNINGS_END + JSC::JITOperationPrologueCallFrameTracer tracer(vm, callFrame); + auto scope = DECLARE_THROW_SCOPE(vm); + + auto* stmt = castedThis->stmt; + CHECK_PREPARED + + int statusCode = sqlite3_reset(stmt); + if (UNLIKELY(statusCode != SQLITE_OK)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errstr(statusCode)))); + return JSValue::encode(jsUndefined()); + } + + int status = sqlite3_step(stmt); + if (!sqlite3_stmt_readonly(stmt)) { + castedThis->version_db->version++; + } + + if (!castedThis->hasExecuted || castedThis->need_update()) { + initializeColumnNames(lexicalGlobalObject, castedThis); + } + + JSValue result = jsNull(); + if (status == SQLITE_ROW) { + result = constructResultObject(lexicalGlobalObject, castedThis); + while (status == SQLITE_ROW) { + status = sqlite3_step(stmt); + } + } + + if (status == SQLITE_DONE || status == SQLITE_OK) { + RELEASE_AND_RETURN(scope, JSValue::encode(result)); + } else { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errstr(status)))); + sqlite3_reset(stmt); + return JSValue::encode(jsUndefined()); + } +} + +constexpr JSC::DFG::AbstractHeapKind readKinds[4] = { JSC::DFG::MiscFields, JSC::DFG::HeapObjectCount }; +constexpr JSC::DFG::AbstractHeapKind writeKinds[4] = { JSC::DFG::SideState, JSC::DFG::HeapObjectCount }; + +static const JSC::DOMJIT::Signature DOMJITSignatureForjsSQLStatementExecuteStatementFunctionGet( + jsSQLStatementExecuteStatementFunctionGetWithoutTypeChecking, + JSSQLiteStatement::info(), + JSC::DOMJIT::Effect::forReadWriteKinds(readKinds, writeKinds), + JSC::SpecOther); + +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionRows, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + + JSC::VM& vm = lexicalGlobalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + auto castedThis = jsDynamicCast<JSSQLiteStatement*>(callFrame->thisValue()); + + CHECK_THIS; + + auto* stmt = castedThis->stmt; + CHECK_PREPARED + + int statusCode = sqlite3_reset(stmt); + if (UNLIKELY(statusCode != SQLITE_OK)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errstr(statusCode)))); + sqlite3_reset(stmt); + return JSValue::encode(jsUndefined()); + } + + int count = callFrame->argumentCount(); + if (count > 0) { + auto arg0 = callFrame->argument(0); + DO_REBIND(arg0); + } + + int status = sqlite3_step(stmt); + if (!sqlite3_stmt_readonly(stmt)) { + castedThis->version_db->version++; + } + + if (!castedThis->hasExecuted || castedThis->need_update()) { + initializeColumnNames(lexicalGlobalObject, castedThis); + } + + size_t columnCount = castedThis->columnNames->size(); + JSValue result = jsNull(); + if (status == SQLITE_ROW) { + // this is a count from UPDATE or another query like that + if (columnCount == 0) { + while (status == SQLITE_ROW) { + status = sqlite3_step(stmt); + } + + result = jsNumber(sqlite3_column_count(stmt)); + + } else { + JSC::ObjectInitializationScope initializationScope(vm); + JSC::GCDeferralContext deferralContext(vm); + + JSC::JSArray* resultArray = JSC::constructEmptyArray(lexicalGlobalObject, nullptr, 0); + { + + while (status == SQLITE_ROW) { + JSC::JSValue row = constructResultRow(lexicalGlobalObject, castedThis, initializationScope, &deferralContext); + resultArray->push(lexicalGlobalObject, row); + status = sqlite3_step(stmt); + } + } + + result = resultArray; + } + } else if (status == SQLITE_DONE && columnCount != 0) { + // breaking change in Bun v0.6.8 + result = JSC::constructEmptyArray(lexicalGlobalObject, nullptr, 0); + } + + if (UNLIKELY(status != SQLITE_DONE && status != SQLITE_OK)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errstr(status)))); + sqlite3_reset(stmt); + return JSValue::encode(jsUndefined()); + } + + // sqlite3_reset(stmt); + RELEASE_AND_RETURN(scope, JSC::JSValue::encode(result)); +} + +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementExecuteStatementFunctionRun, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + + JSC::VM& vm = lexicalGlobalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + auto castedThis = jsDynamicCast<JSSQLiteStatement*>(callFrame->thisValue()); + + CHECK_THIS + + auto* stmt = castedThis->stmt; + CHECK_PREPARED + + int statusCode = sqlite3_reset(stmt); + if (UNLIKELY(statusCode != SQLITE_OK)) { + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errstr(statusCode)))); + return JSValue::encode(jsUndefined()); + } + + if (callFrame->argumentCount() > 0) { + auto arg0 = callFrame->argument(0); + DO_REBIND(arg0); + } + + int status = sqlite3_step(stmt); + if (!sqlite3_stmt_readonly(stmt)) { + castedThis->version_db->version++; + } + + if (!castedThis->hasExecuted || castedThis->need_update()) { + initializeColumnNames(lexicalGlobalObject, castedThis); + } + + while (status == SQLITE_ROW) { + status = sqlite3_step(stmt); + } + + if (UNLIKELY(status != SQLITE_DONE && status != SQLITE_OK)) { + sqlite3_reset(stmt); + throwException(lexicalGlobalObject, scope, createError(lexicalGlobalObject, WTF::String::fromUTF8(sqlite3_errstr(status)))); + return JSValue::encode(jsUndefined()); + } + + RELEASE_AND_RETURN(scope, JSC::JSValue::encode(jsUndefined())); +} + +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementToStringFunction, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + JSC::VM& vm = lexicalGlobalObject->vm(); + JSSQLiteStatement* castedThis = jsDynamicCast<JSSQLiteStatement*>(callFrame->thisValue()); + auto scope = DECLARE_THROW_SCOPE(vm); + + CHECK_THIS + + char* string = sqlite3_expanded_sql(castedThis->stmt); + if (!string) { + RELEASE_AND_RETURN(scope, JSValue::encode(jsEmptyString(vm))); + } + size_t length = strlen(string); + JSString* jsString = JSC::jsString(vm, WTF::String::fromUTF8(string, length)); + sqlite3_free(string); + + RELEASE_AND_RETURN(scope, JSValue::encode(jsString)); +} + +JSC_DEFINE_CUSTOM_GETTER(jsSqlStatementGetColumnNames, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName)) +{ + JSC::VM& vm = lexicalGlobalObject->vm(); + JSSQLiteStatement* castedThis = jsDynamicCast<JSSQLiteStatement*>(JSValue::decode(thisValue)); + auto scope = DECLARE_THROW_SCOPE(vm); + CHECK_THIS + + if (!castedThis->hasExecuted || castedThis->need_update()) { + initializeColumnNames(lexicalGlobalObject, castedThis); + } + JSC::JSArray* array; + auto* columnNames = castedThis->columnNames.get(); + if (columnNames->size() > 0) { + if (castedThis->_prototype) { + array = ownPropertyKeys(lexicalGlobalObject, castedThis->_prototype.get(), PropertyNameMode::Strings, DontEnumPropertiesMode::Exclude); + } else { + array = JSC::constructEmptyArray(lexicalGlobalObject, nullptr, columnNames->size()); + unsigned int i = 0; + for (const auto column : *columnNames) { + array->putDirectIndex(lexicalGlobalObject, i++, jsString(vm, column.string())); + } + } + } else { + array = JSC::constructEmptyArray(lexicalGlobalObject, nullptr, 0); + } + return JSC::JSValue::encode(array); +} + +JSC_DEFINE_CUSTOM_GETTER(jsSqlStatementGetColumnCount, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName)) +{ + JSC::VM& vm = lexicalGlobalObject->vm(); + JSSQLiteStatement* castedThis = jsDynamicCast<JSSQLiteStatement*>(JSValue::decode(thisValue)); + auto scope = DECLARE_THROW_SCOPE(vm); + CHECK_THIS + CHECK_PREPARED + + RELEASE_AND_RETURN(scope, JSValue::encode(JSC::jsNumber(sqlite3_column_count(castedThis->stmt)))); +} + +JSC_DEFINE_CUSTOM_GETTER(jsSqlStatementGetParamCount, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName)) +{ + JSC::VM& vm = lexicalGlobalObject->vm(); + JSSQLiteStatement* castedThis = jsDynamicCast<JSSQLiteStatement*>(JSValue::decode(thisValue)); + auto scope = DECLARE_THROW_SCOPE(vm); + CHECK_THIS + CHECK_PREPARED + + RELEASE_AND_RETURN(scope, JSC::JSValue::encode(JSC::jsNumber(sqlite3_bind_parameter_count(castedThis->stmt)))); +} + +JSC_DEFINE_HOST_FUNCTION(jsSQLStatementFunctionFinalize, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame)) +{ + JSC::VM& vm = lexicalGlobalObject->vm(); + JSSQLiteStatement* castedThis = jsDynamicCast<JSSQLiteStatement*>(callFrame->thisValue()); + auto scope = DECLARE_THROW_SCOPE(vm); + CHECK_THIS + + if (castedThis->stmt) { + sqlite3_finalize(castedThis->stmt); + castedThis->stmt = nullptr; + } + + RELEASE_AND_RETURN(scope, JSValue::encode(jsUndefined())); +} + +const ClassInfo JSSQLiteStatement::s_info = { "SQLStatement"_s, nullptr, nullptr, nullptr, CREATE_METHOD_TABLE(JSSQLiteStatement) }; + +/* Hash table for prototype */ +static const HashTableValue JSSQLiteStatementTableValues[] = { + { "run"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementExecuteStatementFunctionRun, 1 } }, + { "get"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction), NoIntrinsic, { HashTableValue::DOMJITFunctionType, jsSQLStatementExecuteStatementFunctionGet, &DOMJITSignatureForjsSQLStatementExecuteStatementFunctionGet } }, + { "all"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementExecuteStatementFunctionAll, 1 } }, + { "values"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementExecuteStatementFunctionRows, 1 } }, + { "finalize"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementFunctionFinalize, 0 } }, + { "toString"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsSQLStatementToStringFunction, 0 } }, + { "columns"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsSqlStatementGetColumnNames, 0 } }, + { "columnsCount"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsSqlStatementGetColumnCount, 0 } }, + { "paramsCount"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsSqlStatementGetParamCount, 0 } }, +}; + +void JSSQLiteStatement::finishCreation(VM& vm) +{ + Base::finishCreation(vm); + reifyStaticProperties(vm, JSSQLiteStatement::info(), JSSQLiteStatementTableValues, *this); +} + +JSSQLiteStatement::~JSSQLiteStatement() +{ + if (this->stmt) { + sqlite3_finalize(this->stmt); + } +} + +JSC::JSValue JSSQLiteStatement::rebind(JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSValue values, bool clone) +{ + JSC::VM& vm = lexicalGlobalObject->vm(); + auto scope = DECLARE_THROW_SCOPE(vm); + auto* stmt = this->stmt; + auto val = rebindStatement(lexicalGlobalObject, values, scope, stmt, clone); + if (val.isNumber()) { + RELEASE_AND_RETURN(scope, val); + } else { + return val; + } +} + +template<typename Visitor> +void JSSQLiteStatement::visitChildrenImpl(JSCell* cell, Visitor& visitor) +{ + JSSQLiteStatement* thisObject = jsCast<JSSQLiteStatement*>(cell); + ASSERT_GC_OBJECT_INHERITS(thisObject, info()); + Base::visitChildren(thisObject, visitor); + visitor.append(thisObject->_structure); + visitor.append(thisObject->_prototype); +} + +DEFINE_VISIT_CHILDREN(JSSQLiteStatement); + +template<typename Visitor> +void JSSQLiteStatement::visitAdditionalChildren(Visitor& visitor) +{ + JSSQLiteStatement* thisObject = this; + ASSERT_GC_OBJECT_INHERITS(thisObject, info()); + + visitor.append(thisObject->_structure); + visitor.append(thisObject->_prototype); +} + +template<typename Visitor> +void JSSQLiteStatement::visitOutputConstraints(JSCell* cell, Visitor& visitor) +{ + auto* thisObject = jsCast<JSSQLiteStatement*>(cell); + ASSERT_GC_OBJECT_INHERITS(thisObject, info()); + Base::visitOutputConstraints(thisObject, visitor); + thisObject->visitAdditionalChildren(visitor); +} + +template void JSSQLiteStatement::visitOutputConstraints(JSCell*, AbstractSlotVisitor&); +template void JSSQLiteStatement::visitOutputConstraints(JSCell*, SlotVisitor&); +} |