Remove usage of lzz

Co-authored-by: Joshua Wise <[email protected]>

.gitattributes

@@ -1,5 +1 @@
 *.lzz linguist-language=C++
-*.cpp -diff
-*.hpp -diff
-*.c -diff
-*.h -diff

package.json

@@ -44,13 +44,10 @@
     "install": "prebuild-install || node-gyp rebuild --release",
     "build-release": "node-gyp rebuild --release",
     "build-debug": "node-gyp rebuild --debug",
-    "rebuild-release": "npm run lzz && npm run build-release",
-    "rebuild-debug": "npm run lzz && npm run build-debug",
     "test": "mocha --exit --slow=75 --timeout=30000",
     "test:container": "docker-compose up --detach --build",
     "benchmark": "node benchmark",
     "update-sqlite3mc": "bash ./deps/update-sqlite3mc.sh",
-    "lzz": "lzz -hx hpp -sx cpp -k BETTER_SQLITE3 -d -hl -sl -e ./src/better_sqlite3.lzz",
     "bump:patch": "npm --no-git-tag-version version patch",
     "bump:minor": "npm --no-git-tag-version version minor",
     "bump:major": "npm --no-git-tag-version version major",

src/addon.cpp

@@ -0,0 +1,31 @@
+struct Addon {
+	explicit Addon(v8::Isolate* isolate) :
+		privileged_info(NULL),
+		next_id(0),
+		cs(isolate) {}
+
+	static void Cleanup(void* ptr) {
+		Addon* addon = static_cast<Addon*>(ptr);
+		for (Database* db : addon->dbs) db->CloseHandles();
+		addon->dbs.clear();
+		delete addon;
+	}
+
+	inline sqlite3_uint64 NextId() {
+		return next_id++;
+	}
+
+	static NODE_METHOD(JS_setErrorConstructor) {
+		REQUIRE_ARGUMENT_FUNCTION(first, v8::Local<v8::Function> SqliteError);
+		OnlyAddon->SqliteError.Reset(OnlyIsolate, SqliteError);
+	}
+
+	v8::Global<v8::Function> Statement;
+	v8::Global<v8::Function> StatementIterator;
+	v8::Global<v8::Function> Backup;
+	v8::Global<v8::Function> SqliteError;
+	NODE_ARGUMENTS_POINTER privileged_info;
+	sqlite3_uint64 next_id;
+	CS cs;
+	std::set<Database*, Database::CompareDatabase> dbs;
+};

src/better_sqlite3.lzz

@@ -1,88 +0,0 @@
-#hdr
-#include <climits>
-#include <cstdio>
-#include <cstring>
-#include <string>
-#include <vector>
-#include <set>
-#include <unordered_map>
-#include <algorithm>
-#include <sqlite3.h>
-#include <node.h>
-#include <node_object_wrap.h>
-#include <node_buffer.h>
-#end
-
-#insert "util/macros.lzz"
-#insert "util/query-macros.lzz"
-#insert "util/constants.lzz"
-#insert "util/bind-map.lzz"
-struct Addon;
-class Statement;
-class Backup;
-#insert "objects/database.lzz"
-#insert "objects/statement.lzz"
-#insert "objects/statement-iterator.lzz"
-#insert "objects/backup.lzz"
-#insert "util/data-converter.lzz"
-#insert "util/custom-function.lzz"
-#insert "util/custom-aggregate.lzz"
-#insert "util/custom-table.lzz"
-#insert "util/data.lzz"
-#insert "util/binder.lzz"
-
-struct Addon {
-	NODE_METHOD(JS_setErrorConstructor) {
-		REQUIRE_ARGUMENT_FUNCTION(first, v8::Local<v8::Function> SqliteError);
-		OnlyAddon->SqliteError.Reset(OnlyIsolate, SqliteError);
-	}
-
-	static void Cleanup(void* ptr) {
-		Addon* addon = static_cast<Addon*>(ptr);
-		for (Database* db : addon->dbs) db->CloseHandles();
-		addon->dbs.clear();
-		delete addon;
-	}
-
-	explicit Addon(v8::Isolate* isolate) :
-		privileged_info(NULL),
-		next_id(0),
-		cs(isolate) {}
-
-	inline sqlite3_uint64 NextId() {
-		return next_id++;
-	}
-
-	v8::Global<v8::Function> Statement;
-	v8::Global<v8::Function> StatementIterator;
-	v8::Global<v8::Function> Backup;
-	v8::Global<v8::Function> SqliteError;
-	NODE_ARGUMENTS_POINTER privileged_info;
-	sqlite3_uint64 next_id;
-	CS cs;
-	std::set<Database*, Database::CompareDatabase> dbs;
-};
-
-#src
-NODE_MODULE_INIT(/* exports, context */) {
-	v8::Isolate* isolate = context->GetIsolate();
-	v8::HandleScope scope(isolate);
-
-	// Initialize addon instance.
-	Addon* addon = new Addon(isolate);
-	v8::Local<v8::External> data = v8::External::New(isolate, addon);
-	node::AddEnvironmentCleanupHook(isolate, Addon::Cleanup, addon);
-
-	// Create and export native-backed classes and functions.
-	exports->Set(context, InternalizedFromLatin1(isolate, "Database"), Database::Init(isolate, data)).FromJust();
-	exports->Set(context, InternalizedFromLatin1(isolate, "Statement"), Statement::Init(isolate, data)).FromJust();
-	exports->Set(context, InternalizedFromLatin1(isolate, "StatementIterator"), StatementIterator::Init(isolate, data)).FromJust();
-	exports->Set(context, InternalizedFromLatin1(isolate, "Backup"), Backup::Init(isolate, data)).FromJust();
-	exports->Set(context, InternalizedFromLatin1(isolate, "setErrorConstructor"), v8::FunctionTemplate::New(isolate, Addon::JS_setErrorConstructor, data)->GetFunction(context).ToLocalChecked()).FromJust();
-
-	// Store addon instance data.
-	addon->Statement.Reset(isolate, exports->Get(context, InternalizedFromLatin1(isolate, "Statement")).ToLocalChecked().As<v8::Function>());
-	addon->StatementIterator.Reset(isolate, exports->Get(context, InternalizedFromLatin1(isolate, "StatementIterator")).ToLocalChecked().As<v8::Function>());
-	addon->Backup.Reset(isolate, exports->Get(context, InternalizedFromLatin1(isolate, "Backup")).ToLocalChecked().As<v8::Function>());
-}
-#end

src/objects/backup.cpp

@@ -0,0 +1,120 @@
+Backup::Backup(
+	Database* db,
+	sqlite3* dest_handle,
+	sqlite3_backup* backup_handle,
+	sqlite3_uint64 id,
+	bool unlink
+) :
+	node::ObjectWrap(),
+	db(db),
+	dest_handle(dest_handle),
+	backup_handle(backup_handle),
+	id(id),
+	alive(true),
+	unlink(unlink) {
+	assert(db != NULL);
+	assert(dest_handle != NULL);
+	assert(backup_handle != NULL);
+	db->AddBackup(this);
+}
+
+Backup::~Backup() {
+	if (alive) db->RemoveBackup(this);
+	CloseHandles();
+}
+
+// Whenever this is used, db->RemoveBackup must be invoked beforehand.
+void Backup::CloseHandles() {
+	if (alive) {
+		alive = false;
+		std::string filename(sqlite3_db_filename(dest_handle, "main"));
+		sqlite3_backup_finish(backup_handle);
+		int status = sqlite3_close(dest_handle);
+		assert(status == SQLITE_OK); ((void)status);
+		if (unlink) remove(filename.c_str());
+	}
+}
+
+INIT(Backup::Init) {
+	v8::Local<v8::FunctionTemplate> t = NewConstructorTemplate(isolate, data, JS_new, "Backup");
+	SetPrototypeMethod(isolate, data, t, "transfer", JS_transfer);
+	SetPrototypeMethod(isolate, data, t, "close", JS_close);
+	return t->GetFunction(OnlyContext).ToLocalChecked();
+}
+
+NODE_METHOD(Backup::JS_new) {
+	UseAddon;
+	if (!addon->privileged_info) return ThrowTypeError("Disabled constructor");
+	assert(info.IsConstructCall());
+	Database* db = Unwrap<Database>(addon->privileged_info->This());
+	REQUIRE_DATABASE_OPEN(db->GetState());
+	REQUIRE_DATABASE_NOT_BUSY(db->GetState());
+
+	v8::Local<v8::Object> database = (*addon->privileged_info)[0].As<v8::Object>();
+	v8::Local<v8::String> attachedName = (*addon->privileged_info)[1].As<v8::String>();
+	v8::Local<v8::String> destFile = (*addon->privileged_info)[2].As<v8::String>();
+	bool unlink = (*addon->privileged_info)[3].As<v8::Boolean>()->Value();
+
+	UseIsolate;
+	sqlite3* dest_handle;
+	v8::String::Utf8Value dest_file(isolate, destFile);
+	v8::String::Utf8Value attached_name(isolate, attachedName);
+	int mask = (SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
+
+	if (sqlite3_open_v2(*dest_file, &dest_handle, mask, NULL) != SQLITE_OK) {
+		Database::ThrowSqliteError(addon, dest_handle);
+		int status = sqlite3_close(dest_handle);
+		assert(status == SQLITE_OK); ((void)status);
+		return;
+	}
+
+	sqlite3_extended_result_codes(dest_handle, 1);
+	sqlite3_limit(dest_handle, SQLITE_LIMIT_LENGTH, INT_MAX);
+	sqlite3_backup* backup_handle = sqlite3_backup_init(dest_handle, "main", db->GetHandle(), *attached_name);
+	if (backup_handle == NULL) {
+		Database::ThrowSqliteError(addon, dest_handle);
+		int status = sqlite3_close(dest_handle);
+		assert(status == SQLITE_OK); ((void)status);
+		return;
+	}
+
+	Backup* backup = new Backup(db, dest_handle, backup_handle, addon->NextId(), unlink);
+	backup->Wrap(info.This());
+	SetFrozen(isolate, OnlyContext, info.This(), addon->cs.database, database);
+
+	info.GetReturnValue().Set(info.This());
+}
+
+NODE_METHOD(Backup::JS_transfer) {
+	Backup* backup = Unwrap<Backup>(info.This());
+	REQUIRE_ARGUMENT_INT32(first, int pages);
+	REQUIRE_DATABASE_OPEN(backup->db->GetState());
+	assert(backup->db->GetState()->busy == false);
+	assert(backup->alive == true);
+
+	sqlite3_backup* backup_handle = backup->backup_handle;
+	int status = sqlite3_backup_step(backup_handle, pages) & 0xff;
+
+	Addon* addon = backup->db->GetAddon();
+	if (status == SQLITE_OK || status == SQLITE_DONE || status == SQLITE_BUSY) {
+		int total_pages = sqlite3_backup_pagecount(backup_handle);
+		int remaining_pages = sqlite3_backup_remaining(backup_handle);
+		UseIsolate;
+		UseContext;
+		v8::Local<v8::Object> result = v8::Object::New(isolate);
+		result->Set(ctx, addon->cs.totalPages.Get(isolate), v8::Int32::New(isolate, total_pages)).FromJust();
+		result->Set(ctx, addon->cs.remainingPages.Get(isolate), v8::Int32::New(isolate, remaining_pages)).FromJust();
+		info.GetReturnValue().Set(result);
+		if (status == SQLITE_DONE) backup->unlink = false;
+	} else {
+		Database::ThrowSqliteError(addon, sqlite3_errstr(status), status);
+	}
+}
+
+NODE_METHOD(Backup::JS_close) {
+	Backup* backup = Unwrap<Backup>(info.This());
+	assert(backup->db->GetState()->busy == false);
+	if (backup->alive) backup->db->RemoveBackup(backup);
+	backup->CloseHandles();
+	info.GetReturnValue().Set(info.This());
+}

src/objects/backup.hpp

@@ -0,0 +1,36 @@
+class Backup : public node::ObjectWrap {
+public:
+
+	~Backup();
+
+	// Whenever this is used, db->RemoveBackup must be invoked beforehand.
+	void CloseHandles();
+
+	// Used to support ordered containers.
+	static inline bool Compare(Backup const * const a, Backup const * const b) {
+		return a->id < b->id;
+	}
+
+	static INIT(Init);
+
+private:
+
+	explicit Backup(
+		Database* db,
+		sqlite3* dest_handle,
+		sqlite3_backup* backup_handle,
+		sqlite3_uint64 id,
+		bool unlink
+	);
+
+	static NODE_METHOD(JS_new);
+	static NODE_METHOD(JS_transfer);
+	static NODE_METHOD(JS_close);
+
+	Database* const db;
+	sqlite3* const dest_handle;
+	sqlite3_backup* const backup_handle;
+	const sqlite3_uint64 id;
+	bool alive;
+	bool unlink;
+};

src/objects/backup.lzz

@@ -1,138 +0,0 @@
-class Backup : public node::ObjectWrap {
-public:
-
-	INIT(Init) {
-		v8::Local<v8::FunctionTemplate> t = NewConstructorTemplate(isolate, data, JS_new, "Backup");
-		SetPrototypeMethod(isolate, data, t, "transfer", JS_transfer);
-		SetPrototypeMethod(isolate, data, t, "close", JS_close);
-		return t->GetFunction(OnlyContext).ToLocalChecked();
-	}
-
-	// Used to support ordered containers.
-	static inline bool Compare(Backup const * const a, Backup const * const b) {
-		return a->id < b->id;
-	}
-
-	// Whenever this is used, db->RemoveBackup must be invoked beforehand.
-	void CloseHandles() {
-		if (alive) {
-			alive = false;
-			std::string filename(sqlite3_db_filename(dest_handle, "main"));
-			sqlite3_backup_finish(backup_handle);
-			int status = sqlite3_close(dest_handle);
-			assert(status == SQLITE_OK); ((void)status);
-			if (unlink) remove(filename.c_str());
-		}
-	}
-
-	~Backup() {
-		if (alive) db->RemoveBackup(this);
-		CloseHandles();
-	}
-
-private:
-
-	explicit Backup(
-		Database* db,
-		sqlite3* dest_handle,
-		sqlite3_backup* backup_handle,
-		sqlite3_uint64 id,
-		bool unlink
-	) :
-		node::ObjectWrap(),
-		db(db),
-		dest_handle(dest_handle),
-		backup_handle(backup_handle),
-		id(id),
-		alive(true),
-		unlink(unlink) {
-		assert(db != NULL);
-		assert(dest_handle != NULL);
-		assert(backup_handle != NULL);
-		db->AddBackup(this);
-	}
-
-	NODE_METHOD(JS_new) {
-		UseAddon;
-		if (!addon->privileged_info) return ThrowTypeError("Disabled constructor");
-		assert(info.IsConstructCall());
-		Database* db = Unwrap<Database>(addon->privileged_info->This());
-		REQUIRE_DATABASE_OPEN(db->GetState());
-		REQUIRE_DATABASE_NOT_BUSY(db->GetState());
-
-		v8::Local<v8::Object> database = (*addon->privileged_info)[0].As<v8::Object>();
-		v8::Local<v8::String> attachedName = (*addon->privileged_info)[1].As<v8::String>();
-		v8::Local<v8::String> destFile = (*addon->privileged_info)[2].As<v8::String>();
-		bool unlink = (*addon->privileged_info)[3].As<v8::Boolean>()->Value();
-
-		UseIsolate;
-		sqlite3* dest_handle;
-		v8::String::Utf8Value dest_file(isolate, destFile);
-		v8::String::Utf8Value attached_name(isolate, attachedName);
-		int mask = (SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
-
-		if (sqlite3_open_v2(*dest_file, &dest_handle, mask, NULL) != SQLITE_OK) {
-			Database::ThrowSqliteError(addon, dest_handle);
-			int status = sqlite3_close(dest_handle);
-			assert(status == SQLITE_OK); ((void)status);
-			return;
-		}
-
-		sqlite3_extended_result_codes(dest_handle, 1);
-		sqlite3_limit(dest_handle, SQLITE_LIMIT_LENGTH, INT_MAX);
-		sqlite3_backup* backup_handle = sqlite3_backup_init(dest_handle, "main", db->GetHandle(), *attached_name);
-		if (backup_handle == NULL) {
-			Database::ThrowSqliteError(addon, dest_handle);
-			int status = sqlite3_close(dest_handle);
-			assert(status == SQLITE_OK); ((void)status);
-			return;
-		}
-
-		Backup* backup = new Backup(db, dest_handle, backup_handle, addon->NextId(), unlink);
-		backup->Wrap(info.This());
-		SetFrozen(isolate, OnlyContext, info.This(), addon->cs.database, database);
-
-		info.GetReturnValue().Set(info.This());
-	}
-
-	NODE_METHOD(JS_transfer) {
-		Backup* backup = Unwrap<Backup>(info.This());
-		REQUIRE_ARGUMENT_INT32(first, int pages);
-		REQUIRE_DATABASE_OPEN(backup->db->GetState());
-		assert(backup->db->GetState()->busy == false);
-		assert(backup->alive == true);
-
-		sqlite3_backup* backup_handle = backup->backup_handle;
-		int status = sqlite3_backup_step(backup_handle, pages) & 0xff;
-
-		Addon* addon = backup->db->GetAddon();
-		if (status == SQLITE_OK || status == SQLITE_DONE || status == SQLITE_BUSY) {
-			int total_pages = sqlite3_backup_pagecount(backup_handle);
-			int remaining_pages = sqlite3_backup_remaining(backup_handle);
-			UseIsolate;
-			UseContext;
-			v8::Local<v8::Object> result = v8::Object::New(isolate);
-			result->Set(ctx, addon->cs.totalPages.Get(isolate), v8::Int32::New(isolate, total_pages)).FromJust();
-			result->Set(ctx, addon->cs.remainingPages.Get(isolate), v8::Int32::New(isolate, remaining_pages)).FromJust();
-			info.GetReturnValue().Set(result);
-			if (status == SQLITE_DONE) backup->unlink = false;
-		} else {
-			Database::ThrowSqliteError(addon, sqlite3_errstr(status), status);
-		}
-	}
-
-	NODE_METHOD(JS_close) {
-		Backup* backup = Unwrap<Backup>(info.This());
-		assert(backup->db->GetState()->busy == false);
-		if (backup->alive) backup->db->RemoveBackup(backup);
-		backup->CloseHandles();
-		info.GetReturnValue().Set(info.This());
-	}
-
-	Database* const db;
-	sqlite3* const dest_handle;
-	sqlite3_backup* const backup_handle;
-	const sqlite3_uint64 id;
-	bool alive;
-	bool unlink;
-};

src/objects/database.cpp

@@ -0,0 +1,417 @@
+const int Database::MAX_BUFFER_SIZE = (
+	node::Buffer::kMaxLength > INT_MAX
+		? INT_MAX
+		: static_cast<int>(node::Buffer::kMaxLength)
+);
+
+const int Database::MAX_STRING_SIZE = (
+	v8::String::kMaxLength > INT_MAX
+		? INT_MAX
+		: static_cast<int>(v8::String::kMaxLength)
+);
+
+Database::Database(
+	v8::Isolate* isolate,
+	Addon* addon,
+	sqlite3* db_handle,
+	v8::Local<v8::Value> logger
+) :
+	node::ObjectWrap(),
+	db_handle(db_handle),
+	open(true),
+	busy(false),
+	safe_ints(false),
+	unsafe_mode(false),
+	was_js_error(false),
+	has_logger(logger->IsFunction()),
+	iterators(0),
+	addon(addon),
+	logger(isolate, logger),
+	stmts(),
+	backups() {
+	assert(db_handle != NULL);
+	addon->dbs.insert(this);
+}
+
+Database::~Database() {
+	if (open) addon->dbs.erase(this);
+	CloseHandles();
+}
+
+// Whenever this is used, addon->dbs.erase() must be invoked beforehand.
+void Database::CloseHandles() {
+	if (open) {
+		open = false;
+		for (Statement* stmt : stmts) stmt->CloseHandles();
+		for (Backup* backup : backups) backup->CloseHandles();
+		stmts.clear();
+		backups.clear();
+		int status = sqlite3_close(db_handle);
+		assert(status == SQLITE_OK); ((void)status);
+	}
+}
+
+void Database::ThrowDatabaseError() {
+	if (was_js_error) was_js_error = false;
+	else ThrowSqliteError(addon, db_handle);
+}
+
+void Database::ThrowSqliteError(Addon* addon, sqlite3* db_handle) {
+	assert(db_handle != NULL);
+	ThrowSqliteError(addon, sqlite3_errmsg(db_handle), sqlite3_extended_errcode(db_handle));
+}
+
+void Database::ThrowSqliteError(Addon* addon, const char* message, int code) {
+	assert(message != NULL);
+	assert((code & 0xff) != SQLITE_OK);
+	assert((code & 0xff) != SQLITE_ROW);
+	assert((code & 0xff) != SQLITE_DONE);
+	EasyIsolate;
+	v8::Local<v8::Value> args[2] = {
+		StringFromUtf8(isolate, message, -1),
+		addon->cs.Code(isolate, code)
+	};
+	isolate->ThrowException(addon->SqliteError.Get(isolate)
+		->NewInstance(OnlyContext, 2, args)
+		.ToLocalChecked());
+}
+
+// Allows Statements to log their executed SQL.
+bool Database::Log(v8::Isolate* isolate, sqlite3_stmt* handle) {
+	assert(was_js_error == false);
+	if (!has_logger) return false;
+	char* expanded = sqlite3_expanded_sql(handle);
+	v8::Local<v8::Value> arg = StringFromUtf8(isolate, expanded ? expanded : sqlite3_sql(handle), -1);
+	was_js_error = logger.Get(isolate).As<v8::Function>()
+		->Call(OnlyContext, v8::Undefined(isolate), 1, &arg)
+		.IsEmpty();
+	if (expanded) sqlite3_free(expanded);
+	return was_js_error;
+}
+
+bool Database::Deserialize(
+	v8::Local<v8::Object> buffer,
+	Addon* addon,
+	sqlite3* db_handle,
+	bool readonly
+) {
+	size_t length = node::Buffer::Length(buffer);
+	unsigned char* data = (unsigned char*)sqlite3_malloc64(length);
+	unsigned int flags = SQLITE_DESERIALIZE_FREEONCLOSE | SQLITE_DESERIALIZE_RESIZEABLE;
+
+	if (readonly) {
+		flags |= SQLITE_DESERIALIZE_READONLY;
+	}
+	if (length) {
+		if (!data) {
+			ThrowError("Out of memory");
+			return false;
+		}
+		memcpy(data, node::Buffer::Data(buffer), length);
+	}
+
+	int status = sqlite3_deserialize(db_handle, "main", data, length, length, flags);
+	if (status != SQLITE_OK) {
+		ThrowSqliteError(addon, status == SQLITE_ERROR ? "unable to deserialize database" : sqlite3_errstr(status), status);
+		return false;
+	}
+
+	return true;
+}
+
+void Database::FreeSerialization(char* data, void* _) {
+	sqlite3_free(data);
+}
+
+INIT(Database::Init) {
+	v8::Local<v8::FunctionTemplate> t = NewConstructorTemplate(isolate, data, JS_new, "Database");
+	SetPrototypeMethod(isolate, data, t, "prepare", JS_prepare);
+	SetPrototypeMethod(isolate, data, t, "exec", JS_exec);
+	SetPrototypeMethod(isolate, data, t, "backup", JS_backup);
+	SetPrototypeMethod(isolate, data, t, "serialize", JS_serialize);
+	SetPrototypeMethod(isolate, data, t, "function", JS_function);
+	SetPrototypeMethod(isolate, data, t, "aggregate", JS_aggregate);
+	SetPrototypeMethod(isolate, data, t, "table", JS_table);
+	SetPrototypeMethod(isolate, data, t, "loadExtension", JS_loadExtension);
+	SetPrototypeMethod(isolate, data, t, "close", JS_close);
+	SetPrototypeMethod(isolate, data, t, "defaultSafeIntegers", JS_defaultSafeIntegers);
+	SetPrototypeMethod(isolate, data, t, "unsafeMode", JS_unsafeMode);
+	SetPrototypeGetter(isolate, data, t, "open", JS_open);
+	SetPrototypeGetter(isolate, data, t, "inTransaction", JS_inTransaction);
+	return t->GetFunction(OnlyContext).ToLocalChecked();
+}
+
+NODE_METHOD(Database::JS_new) {
+	assert(info.IsConstructCall());
+	REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> filename);
+	REQUIRE_ARGUMENT_STRING(second, v8::Local<v8::String> filenameGiven);
+	REQUIRE_ARGUMENT_BOOLEAN(third, bool in_memory);
+	REQUIRE_ARGUMENT_BOOLEAN(fourth, bool readonly);
+	REQUIRE_ARGUMENT_BOOLEAN(fifth, bool must_exist);
+	REQUIRE_ARGUMENT_INT32(sixth, int timeout);
+	REQUIRE_ARGUMENT_ANY(seventh, v8::Local<v8::Value> logger);
+	REQUIRE_ARGUMENT_ANY(eighth, v8::Local<v8::Value> buffer);
+
+	UseAddon;
+	UseIsolate;
+	sqlite3* db_handle;
+	v8::String::Utf8Value utf8(isolate, filename);
+	int mask = readonly ? SQLITE_OPEN_READONLY
+		: must_exist ? SQLITE_OPEN_READWRITE
+		: (SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
+
+	if (sqlite3_open_v2(*utf8, &db_handle, mask, NULL) != SQLITE_OK) {
+		ThrowSqliteError(addon, db_handle);
+		int status = sqlite3_close(db_handle);
+		assert(status == SQLITE_OK); ((void)status);
+		return;
+	}
+
+	assert(sqlite3_db_mutex(db_handle) == NULL);
+	sqlite3_extended_result_codes(db_handle, 1);
+	sqlite3_busy_timeout(db_handle, timeout);
+	sqlite3_limit(db_handle, SQLITE_LIMIT_LENGTH, MAX_BUFFER_SIZE < MAX_STRING_SIZE ? MAX_BUFFER_SIZE : MAX_STRING_SIZE);
+	sqlite3_limit(db_handle, SQLITE_LIMIT_SQL_LENGTH, MAX_STRING_SIZE);
+	int status = sqlite3_db_config(db_handle, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, NULL);
+	assert(status == SQLITE_OK);
+	status = sqlite3_db_config(db_handle, SQLITE_DBCONFIG_DEFENSIVE, 1, NULL);
+	assert(status == SQLITE_OK);
+
+	if (node::Buffer::HasInstance(buffer) && !Deserialize(buffer.As<v8::Object>(), addon, db_handle, readonly)) {
+		int status = sqlite3_close(db_handle);
+		assert(status == SQLITE_OK); ((void)status);
+		return;
+	}
+
+	UseContext;
+	Database* db = new Database(isolate, addon, db_handle, logger);
+	db->Wrap(info.This());
+	SetFrozen(isolate, ctx, info.This(), addon->cs.memory, v8::Boolean::New(isolate, in_memory));
+	SetFrozen(isolate, ctx, info.This(), addon->cs.readonly, v8::Boolean::New(isolate, readonly));
+	SetFrozen(isolate, ctx, info.This(), addon->cs.name, filenameGiven);
+
+	info.GetReturnValue().Set(info.This());
+}
+
+NODE_METHOD(Database::JS_prepare) {
+	REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> source);
+	REQUIRE_ARGUMENT_OBJECT(second, v8::Local<v8::Object> database);
+	REQUIRE_ARGUMENT_BOOLEAN(third, bool pragmaMode);
+	(void)source;
+	(void)database;
+	(void)pragmaMode;
+	UseAddon;
+	UseIsolate;
+	v8::Local<v8::Function> c = addon->Statement.Get(isolate);
+	addon->privileged_info = &info;
+	v8::MaybeLocal<v8::Object> maybeStatement = c->NewInstance(OnlyContext, 0, NULL);
+	addon->privileged_info = NULL;
+	if (!maybeStatement.IsEmpty()) info.GetReturnValue().Set(maybeStatement.ToLocalChecked());
+}
+
+NODE_METHOD(Database::JS_exec) {
+	Database* db = Unwrap<Database>(info.This());
+	REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> source);
+	REQUIRE_DATABASE_OPEN(db);
+	REQUIRE_DATABASE_NOT_BUSY(db);
+	REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db);
+	db->busy = true;
+
+	UseIsolate;
+	v8::String::Utf8Value utf8(isolate, source);
+	const char* sql = *utf8;
+	const char* tail;
+
+	int status;
+	const bool has_logger = db->has_logger;
+	sqlite3* const db_handle = db->db_handle;
+	sqlite3_stmt* handle;
+
+	for (;;) {
+		while (IS_SKIPPED(*sql)) ++sql;
+		status = sqlite3_prepare_v2(db_handle, sql, -1, &handle, &tail);
+		sql = tail;
+		if (!handle) break;
+		if (has_logger && db->Log(isolate, handle)) {
+			sqlite3_finalize(handle);
+			status = -1;
+			break;
+		}
+		do status = sqlite3_step(handle);
+		while (status == SQLITE_ROW);
+		status = sqlite3_finalize(handle);
+		if (status != SQLITE_OK) break;
+	}
+
+	db->busy = false;
+	if (status != SQLITE_OK) {
+		db->ThrowDatabaseError();
+	}
+}
+
+NODE_METHOD(Database::JS_backup) {
+	REQUIRE_ARGUMENT_OBJECT(first, v8::Local<v8::Object> database);
+	REQUIRE_ARGUMENT_STRING(second, v8::Local<v8::String> attachedName);
+	REQUIRE_ARGUMENT_STRING(third, v8::Local<v8::String> destFile);
+	REQUIRE_ARGUMENT_BOOLEAN(fourth, bool unlink);
+	(void)database;
+	(void)attachedName;
+	(void)destFile;
+	(void)unlink;
+	UseAddon;
+	UseIsolate;
+	v8::Local<v8::Function> c = addon->Backup.Get(isolate);
+	addon->privileged_info = &info;
+	v8::MaybeLocal<v8::Object> maybeBackup = c->NewInstance(OnlyContext, 0, NULL);
+	addon->privileged_info = NULL;
+	if (!maybeBackup.IsEmpty()) info.GetReturnValue().Set(maybeBackup.ToLocalChecked());
+}
+
+NODE_METHOD(Database::JS_serialize) {
+	Database* db = Unwrap<Database>(info.This());
+	REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> attachedName);
+	REQUIRE_DATABASE_OPEN(db);
+	REQUIRE_DATABASE_NOT_BUSY(db);
+	REQUIRE_DATABASE_NO_ITERATORS(db);
+
+	UseIsolate;
+	v8::String::Utf8Value attached_name(isolate, attachedName);
+	sqlite3_int64 length = -1;
+	unsigned char* data = sqlite3_serialize(db->db_handle, *attached_name, &length, 0);
+
+	if (!data && length) {
+		ThrowError("Out of memory");
+		return;
+	}
+
+	info.GetReturnValue().Set(
+		SAFE_NEW_BUFFER(isolate, reinterpret_cast<char*>(data), length, FreeSerialization, NULL).ToLocalChecked()
+	);
+}
+
+NODE_METHOD(Database::JS_function) {
+	Database* db = Unwrap<Database>(info.This());
+	REQUIRE_ARGUMENT_FUNCTION(first, v8::Local<v8::Function> fn);
+	REQUIRE_ARGUMENT_STRING(second, v8::Local<v8::String> nameString);
+	REQUIRE_ARGUMENT_INT32(third, int argc);
+	REQUIRE_ARGUMENT_INT32(fourth, int safe_ints);
+	REQUIRE_ARGUMENT_BOOLEAN(fifth, bool deterministic);
+	REQUIRE_ARGUMENT_BOOLEAN(sixth, bool direct_only);
+	REQUIRE_DATABASE_OPEN(db);
+	REQUIRE_DATABASE_NOT_BUSY(db);
+	REQUIRE_DATABASE_NO_ITERATORS(db);
+
+	UseIsolate;
+	v8::String::Utf8Value name(isolate, nameString);
+	int mask = SQLITE_UTF8;
+	if (deterministic) mask |= SQLITE_DETERMINISTIC;
+	if (direct_only) mask |= SQLITE_DIRECTONLY;
+	safe_ints = safe_ints < 2 ? safe_ints : static_cast<int>(db->safe_ints);
+
+	if (sqlite3_create_function_v2(db->db_handle, *name, argc, mask, new CustomFunction(isolate, db, *name, fn, safe_ints), CustomFunction::xFunc, NULL, NULL, CustomFunction::xDestroy) != SQLITE_OK) {
+		db->ThrowDatabaseError();
+	}
+}
+
+NODE_METHOD(Database::JS_aggregate) {
+	Database* db = Unwrap<Database>(info.This());
+	REQUIRE_ARGUMENT_ANY(first, v8::Local<v8::Value> start);
+	REQUIRE_ARGUMENT_FUNCTION(second, v8::Local<v8::Function> step);
+	REQUIRE_ARGUMENT_ANY(third, v8::Local<v8::Value> inverse);
+	REQUIRE_ARGUMENT_ANY(fourth, v8::Local<v8::Value> result);
+	REQUIRE_ARGUMENT_STRING(fifth, v8::Local<v8::String> nameString);
+	REQUIRE_ARGUMENT_INT32(sixth, int argc);
+	REQUIRE_ARGUMENT_INT32(seventh, int safe_ints);
+	REQUIRE_ARGUMENT_BOOLEAN(eighth, bool deterministic);
+	REQUIRE_ARGUMENT_BOOLEAN(ninth, bool direct_only);
+	REQUIRE_DATABASE_OPEN(db);
+	REQUIRE_DATABASE_NOT_BUSY(db);
+	REQUIRE_DATABASE_NO_ITERATORS(db);
+
+	UseIsolate;
+	v8::String::Utf8Value name(isolate, nameString);
+	auto xInverse = inverse->IsFunction() ? CustomAggregate::xInverse : NULL;
+	auto xValue = xInverse ? CustomAggregate::xValue : NULL;
+	int mask = SQLITE_UTF8;
+	if (deterministic) mask |= SQLITE_DETERMINISTIC;
+	if (direct_only) mask |= SQLITE_DIRECTONLY;
+	safe_ints = safe_ints < 2 ? safe_ints : static_cast<int>(db->safe_ints);
+
+	if (sqlite3_create_window_function(db->db_handle, *name, argc, mask, new CustomAggregate(isolate, db, *name, start, step, inverse, result, safe_ints), CustomAggregate::xStep, CustomAggregate::xFinal, xValue, xInverse, CustomAggregate::xDestroy) != SQLITE_OK) {
+		db->ThrowDatabaseError();
+	}
+}
+
+NODE_METHOD(Database::JS_table) {
+	Database* db = Unwrap<Database>(info.This());
+	REQUIRE_ARGUMENT_FUNCTION(first, v8::Local<v8::Function> factory);
+	REQUIRE_ARGUMENT_STRING(second, v8::Local<v8::String> nameString);
+	REQUIRE_ARGUMENT_BOOLEAN(third, bool eponymous);
+	REQUIRE_DATABASE_OPEN(db);
+	REQUIRE_DATABASE_NOT_BUSY(db);
+	REQUIRE_DATABASE_NO_ITERATORS(db);
+
+	UseIsolate;
+	v8::String::Utf8Value name(isolate, nameString);
+	sqlite3_module* module = eponymous ? &CustomTable::EPONYMOUS_MODULE : &CustomTable::MODULE;
+
+	db->busy = true;
+	if (sqlite3_create_module_v2(db->db_handle, *name, module, new CustomTable(isolate, db, *name, factory), CustomTable::Destructor) != SQLITE_OK) {
+		db->ThrowDatabaseError();
+	}
+	db->busy = false;
+}
+
+NODE_METHOD(Database::JS_loadExtension) {
+	Database* db = Unwrap<Database>(info.This());
+	v8::Local<v8::String> entryPoint;
+	REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> filename);
+	if (info.Length() > 1) { REQUIRE_ARGUMENT_STRING(second, entryPoint); }
+	REQUIRE_DATABASE_OPEN(db);
+	REQUIRE_DATABASE_NOT_BUSY(db);
+	REQUIRE_DATABASE_NO_ITERATORS(db);
+	UseIsolate;
+	char* error;
+	int status = sqlite3_load_extension(
+		db->db_handle,
+		*v8::String::Utf8Value(isolate, filename),
+		entryPoint.IsEmpty() ? NULL : *v8::String::Utf8Value(isolate, entryPoint),
+		&error
+	);
+	if (status != SQLITE_OK) {
+		ThrowSqliteError(db->addon, error, status);
+	}
+	sqlite3_free(error);
+}
+
+NODE_METHOD(Database::JS_close) {
+	Database* db = Unwrap<Database>(info.This());
+	if (db->open) {
+		REQUIRE_DATABASE_NOT_BUSY(db);
+		REQUIRE_DATABASE_NO_ITERATORS(db);
+		db->addon->dbs.erase(db);
+		db->CloseHandles();
+	}
+}
+
+NODE_METHOD(Database::JS_defaultSafeIntegers) {
+	Database* db = Unwrap<Database>(info.This());
+	if (info.Length() == 0) db->safe_ints = true;
+	else { REQUIRE_ARGUMENT_BOOLEAN(first, db->safe_ints); }
+}
+
+NODE_METHOD(Database::JS_unsafeMode) {
+	Database* db = Unwrap<Database>(info.This());
+	if (info.Length() == 0) db->unsafe_mode = true;
+	else { REQUIRE_ARGUMENT_BOOLEAN(first, db->unsafe_mode); }
+	sqlite3_db_config(db->db_handle, SQLITE_DBCONFIG_DEFENSIVE, static_cast<int>(!db->unsafe_mode), NULL);
+}
+
+NODE_GETTER(Database::JS_open) {
+	info.GetReturnValue().Set(Unwrap<Database>(info.This())->open);
+}
+
+NODE_GETTER(Database::JS_inTransaction) {
+	Database* db = Unwrap<Database>(info.This());
+	info.GetReturnValue().Set(db->open && !static_cast<bool>(sqlite3_get_autocommit(db->db_handle)));
+}

src/objects/database.hpp

@@ -0,0 +1,103 @@
+class Database : public node::ObjectWrap {
+public:
+
+	~Database();
+
+	// Whenever this is used, addon->dbs.erase() must be invoked beforehand.
+	void CloseHandles();
+
+	// Used to support ordered containers.
+	class CompareDatabase { public:
+		inline bool operator() (Database const * const a, Database const * const b) const {
+			return a < b;
+		}
+	};
+	class CompareStatement { public:
+		inline bool operator() (Statement const * const a, Statement const * const b) const {
+			return Statement::Compare(a, b);
+		}
+	};
+	class CompareBackup { public:
+		inline bool operator() (Backup const * const a, Backup const * const b) const {
+			return Backup::Compare(a, b);
+		}
+	};
+
+	// Proper error handling logic for when an sqlite3 operation fails.
+	void ThrowDatabaseError();
+	static void ThrowSqliteError(Addon* addon, sqlite3* db_handle);
+	static void ThrowSqliteError(Addon* addon, const char* message, int code);
+
+	// Allows Statements to log their executed SQL.
+	bool Log(v8::Isolate* isolate, sqlite3_stmt* handle);
+
+	// Allow Statements to manage themselves when created and garbage collected.
+	inline void AddStatement(Statement* stmt) { stmts.insert(stmts.end(), stmt); }
+	inline void RemoveStatement(Statement* stmt) { stmts.erase(stmt); }
+
+	// Allow Backups to manage themselves when created and garbage collected.
+	inline void AddBackup(Backup* backup) { backups.insert(backups.end(), backup); }
+	inline void RemoveBackup(Backup* backup) { backups.erase(backup); }
+
+	// A view for Statements to see and modify Database state.
+	// The order of these fields must exactly match their actual order.
+	struct State {
+		const bool open;
+		bool busy;
+		const bool safe_ints;
+		const bool unsafe_mode;
+		bool was_js_error;
+		const bool has_logger;
+		unsigned short iterators;
+		Addon* const addon;
+	};
+
+	inline State* GetState() { return reinterpret_cast<State*>(&open); }
+	inline sqlite3* GetHandle() { return db_handle; }
+	inline Addon* GetAddon() { return addon; }
+
+	static INIT(Init);
+
+private:
+
+	explicit Database(
+		v8::Isolate* isolate,
+		Addon* addon,
+		sqlite3* db_handle,
+		v8::Local<v8::Value> logger
+	);
+
+	static NODE_METHOD(JS_new);
+	static NODE_METHOD(JS_prepare);
+	static NODE_METHOD(JS_exec);
+	static NODE_METHOD(JS_backup);
+	static NODE_METHOD(JS_serialize);
+	static NODE_METHOD(JS_function);
+	static NODE_METHOD(JS_aggregate);
+	static NODE_METHOD(JS_table);
+	static NODE_METHOD(JS_loadExtension);
+	static NODE_METHOD(JS_close);
+	static NODE_METHOD(JS_defaultSafeIntegers);
+	static NODE_METHOD(JS_unsafeMode);
+	static NODE_GETTER(JS_open);
+	static NODE_GETTER(JS_inTransaction);
+
+	static bool Deserialize(v8::Local<v8::Object> buffer, Addon* addon, sqlite3* db_handle, bool readonly);
+	static void FreeSerialization(char* data, void* _);
+
+	static const int MAX_BUFFER_SIZE;
+	static const int MAX_STRING_SIZE;
+
+	sqlite3* const db_handle;
+	bool open;
+	bool busy;
+	bool safe_ints;
+	bool unsafe_mode;
+	bool was_js_error;
+	const bool has_logger;
+	unsigned short iterators;
+	Addon* const addon;
+	const v8::Global<v8::Value> logger;
+	std::set<Statement*, CompareStatement> stmts;
+	std::set<Backup*, CompareBackup> backups;
+};

src/objects/database.lzz

@@ -1,508 +0,0 @@
-class Database : public node::ObjectWrap {
-public:
-
-	INIT(Init) {
-		v8::Local<v8::FunctionTemplate> t = NewConstructorTemplate(isolate, data, JS_new, "Database");
-		SetPrototypeMethod(isolate, data, t, "prepare", JS_prepare);
-		SetPrototypeMethod(isolate, data, t, "key", JS_key);
-		SetPrototypeMethod(isolate, data, t, "rekey", JS_rekey);
-		SetPrototypeMethod(isolate, data, t, "exec", JS_exec);
-		SetPrototypeMethod(isolate, data, t, "backup", JS_backup);
-		SetPrototypeMethod(isolate, data, t, "serialize", JS_serialize);
-		SetPrototypeMethod(isolate, data, t, "function", JS_function);
-		SetPrototypeMethod(isolate, data, t, "aggregate", JS_aggregate);
-		SetPrototypeMethod(isolate, data, t, "table", JS_table);
-		SetPrototypeMethod(isolate, data, t, "loadExtension", JS_loadExtension);
-		SetPrototypeMethod(isolate, data, t, "close", JS_close);
-		SetPrototypeMethod(isolate, data, t, "defaultSafeIntegers", JS_defaultSafeIntegers);
-		SetPrototypeMethod(isolate, data, t, "unsafeMode", JS_unsafeMode);
-		SetPrototypeGetter(isolate, data, t, "open", JS_open);
-		SetPrototypeGetter(isolate, data, t, "inTransaction", JS_inTransaction);
-		return t->GetFunction(OnlyContext).ToLocalChecked();
-	}
-
-	// Used to support ordered containers.
-	class CompareDatabase { public:
-		bool operator() (Database const * const a, Database const * const b) const {
-			return a < b;
-		}
-	};
-	class CompareStatement { public:
-		bool operator() (Statement const * const a, Statement const * const b) const {
-			return Statement::Compare(a, b);
-		}
-	};
-	class CompareBackup { public:
-		bool operator() (Backup const * const a, Backup const * const b) const {
-			return Backup::Compare(a, b);
-		}
-	};
-
-	// Proper error handling logic for when an sqlite3 operation fails.
-	void ThrowDatabaseError() {
-		if (was_js_error) was_js_error = false;
-		else ThrowSqliteError(addon, db_handle);
-	}
-	static void ThrowSqliteError(Addon* addon, sqlite3* db_handle) {
-		assert(db_handle != NULL);
-		ThrowSqliteError(addon, sqlite3_errmsg(db_handle), sqlite3_extended_errcode(db_handle));
-	}
-	static void ThrowSqliteError(Addon* addon, const char* message, int code) {
-		assert(message != NULL);
-		assert((code & 0xff) != SQLITE_OK);
-		assert((code & 0xff) != SQLITE_ROW);
-		assert((code & 0xff) != SQLITE_DONE);
-		EasyIsolate;
-		v8::Local<v8::Value> args[2] = {
-			StringFromUtf8(isolate, message, -1),
-			addon->cs.Code(isolate, code)
-		};
-		isolate->ThrowException(addon->SqliteError.Get(isolate)
-			->NewInstance(OnlyContext, 2, args)
-			.ToLocalChecked());
-	}
-
-	// Allows Statements to log their executed SQL.
-	bool Log(v8::Isolate* isolate, sqlite3_stmt* handle) {
-		assert(was_js_error == false);
-		if (!has_logger) return false;
-		char* expanded = sqlite3_expanded_sql(handle);
-		v8::Local<v8::Value> arg = StringFromUtf8(isolate, expanded ? expanded : sqlite3_sql(handle), -1);
-		was_js_error = logger.Get(isolate).As<v8::Function>()
-			->Call(OnlyContext, v8::Undefined(isolate), 1, &arg)
-			.IsEmpty();
-		if (expanded) sqlite3_free(expanded);
-		return was_js_error;
-	}
-
-	// Allow Statements to manage themselves when created and garbage collected.
-	inline void AddStatement(Statement* stmt) { stmts.insert(stmts.end(), stmt); }
-	inline void RemoveStatement(Statement* stmt) { stmts.erase(stmt); }
-
-	// Allow Backups to manage themselves when created and garbage collected.
-	inline void AddBackup(Backup* backup) { backups.insert(backups.end(), backup); }
-	inline void RemoveBackup(Backup* backup) { backups.erase(backup); }
-
-	// A view for Statements to see and modify Database state.
-	// The order of these fields must exactly match their actual order.
-	struct State {
-		const bool open;
-		bool busy;
-		const bool safe_ints;
-		const bool unsafe_mode;
-		bool was_js_error;
-		const bool has_logger;
-		unsigned short iterators;
-		Addon* const addon;
-	};
-	inline State* GetState() {
-		return reinterpret_cast<State*>(&open);
-	}
-	inline sqlite3* GetHandle() {
-		return db_handle;
-	}
-	inline Addon* GetAddon() {
-		return addon;
-	}
-
-	// Whenever this is used, addon->dbs.erase() must be invoked beforehand.
-	void CloseHandles() {
-		if (open) {
-			open = false;
-			for (Statement* stmt : stmts) stmt->CloseHandles();
-			for (Backup* backup : backups) backup->CloseHandles();
-			stmts.clear();
-			backups.clear();
-			int status = sqlite3_close(db_handle);
-			assert(status == SQLITE_OK); ((void)status);
-		}
-	}
-
-	~Database() {
-		if (open) addon->dbs.erase(this);
-		CloseHandles();
-	}
-
-private:
-
-	explicit Database(
-		v8::Isolate* isolate,
-		Addon* addon,
-		sqlite3* db_handle,
-		v8::Local<v8::Value> logger
-	) :
-		node::ObjectWrap(),
-		db_handle(db_handle),
-		open(true),
-		busy(false),
-		safe_ints(false),
-		unsafe_mode(false),
-		was_js_error(false),
-		has_logger(logger->IsFunction()),
-		iterators(0),
-		addon(addon),
-		logger(isolate, logger),
-		stmts(),
-		backups() {
-		assert(db_handle != NULL);
-		addon->dbs.insert(this);
-	}
-
-	NODE_METHOD(JS_new) {
-		assert(info.IsConstructCall());
-		REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> filename);
-		REQUIRE_ARGUMENT_STRING(second, v8::Local<v8::String> filenameGiven);
-		REQUIRE_ARGUMENT_BOOLEAN(third, bool in_memory);
-		REQUIRE_ARGUMENT_BOOLEAN(fourth, bool readonly);
-		REQUIRE_ARGUMENT_BOOLEAN(fifth, bool must_exist);
-		REQUIRE_ARGUMENT_INT32(sixth, int timeout);
-		REQUIRE_ARGUMENT_ANY(seventh, v8::Local<v8::Value> logger);
-		REQUIRE_ARGUMENT_ANY(eighth, v8::Local<v8::Value> buffer);
-
-		UseAddon;
-		UseIsolate;
-		sqlite3* db_handle;
-		v8::String::Utf8Value utf8(isolate, filename);
-		int mask = readonly ? SQLITE_OPEN_READONLY
-			: must_exist ? SQLITE_OPEN_READWRITE
-			: (SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
-
-		if (sqlite3_open_v2(*utf8, &db_handle, mask, NULL) != SQLITE_OK) {
-			ThrowSqliteError(addon, db_handle);
-			int status = sqlite3_close(db_handle);
-			assert(status == SQLITE_OK); ((void)status);
-			return;
-		}
-
-		assert(sqlite3_db_mutex(db_handle) == NULL);
-		sqlite3_extended_result_codes(db_handle, 1);
-		sqlite3_busy_timeout(db_handle, timeout);
-		sqlite3_limit(db_handle, SQLITE_LIMIT_LENGTH, MAX_BUFFER_SIZE < MAX_STRING_SIZE ? MAX_BUFFER_SIZE : MAX_STRING_SIZE);
-		sqlite3_limit(db_handle, SQLITE_LIMIT_SQL_LENGTH, MAX_STRING_SIZE);
-		int status = sqlite3_db_config(db_handle, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, NULL);
-		assert(status == SQLITE_OK);
-		status = sqlite3_db_config(db_handle, SQLITE_DBCONFIG_DEFENSIVE, 1, NULL);
-		assert(status == SQLITE_OK);
-
-		if (node::Buffer::HasInstance(buffer) && !Deserialize(buffer.As<v8::Object>(), addon, db_handle, readonly)) {
-			int status = sqlite3_close(db_handle);
-			assert(status == SQLITE_OK); ((void)status);
-			return;
-		}
-
-		UseContext;
-		Database* db = new Database(isolate, addon, db_handle, logger);
-		db->Wrap(info.This());
-		SetFrozen(isolate, ctx, info.This(), addon->cs.memory, v8::Boolean::New(isolate, in_memory));
-		SetFrozen(isolate, ctx, info.This(), addon->cs.readonly, v8::Boolean::New(isolate, readonly));
-		SetFrozen(isolate, ctx, info.This(), addon->cs.name, filenameGiven);
-
-		info.GetReturnValue().Set(info.This());
-	}
-
-	NODE_METHOD(JS_prepare) {
-		REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> source);
-		REQUIRE_ARGUMENT_OBJECT(second, v8::Local<v8::Object> database);
-		REQUIRE_ARGUMENT_BOOLEAN(third, bool pragmaMode);
-		(void)source;
-		(void)database;
-		(void)pragmaMode;
-		UseAddon;
-		UseIsolate;
-		v8::Local<v8::Function> c = addon->Statement.Get(isolate);
-		addon->privileged_info = &info;
-		v8::MaybeLocal<v8::Object> maybeStatement = c->NewInstance(OnlyContext, 0, NULL);
-		addon->privileged_info = NULL;
-		if (!maybeStatement.IsEmpty()) info.GetReturnValue().Set(maybeStatement.ToLocalChecked());
-	}
-
-	NODE_METHOD(JS_key) {
-		Database* db = Unwrap<Database>(info.This());
-		REQUIRE_ARGUMENT_OBJECT(first, v8::Local<v8::Object> key);
-		REQUIRE_ARGUMENT_INT32(second, unsigned int len);
-		(void)key;
-		(void)len;
-		char* buffer = (char*) node::Buffer::Data(key);
-		REQUIRE_DATABASE_OPEN(db);
-		REQUIRE_DATABASE_NOT_BUSY(db);
-		sqlite3* const db_handle = db->db_handle;
-		int status = sqlite3_key(db_handle, buffer, len);
-		if (status != SQLITE_OK) {
-			db->ThrowSqliteError(db->addon, sqlite3_errstr(status), status);
-		}
-		else {
-			info.GetReturnValue().Set(status);
-		}
-	}
-
-	NODE_METHOD(JS_rekey) {
-		Database* db = Unwrap<Database>(info.This());
-		REQUIRE_ARGUMENT_OBJECT(first, v8::Local<v8::Object> key);
-		REQUIRE_ARGUMENT_INT32(second, unsigned int len);
-		(void)key;
-		(void)len;
-		char* buffer = (char*) node::Buffer::Data(key);
-		REQUIRE_DATABASE_OPEN(db);
-		REQUIRE_DATABASE_NOT_BUSY(db);
-		sqlite3* const db_handle = db->db_handle;
-		int status = sqlite3_rekey(db_handle, buffer, len);
-		if (status != SQLITE_OK) {
-			db->ThrowSqliteError(db->addon, sqlite3_errstr(status), status);
-		}
-		else {
-			info.GetReturnValue().Set(status);
-		}
-	}
-
-	NODE_METHOD(JS_exec) {
-		Database* db = Unwrap<Database>(info.This());
-		REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> source);
-		REQUIRE_DATABASE_OPEN(db);
-		REQUIRE_DATABASE_NOT_BUSY(db);
-		REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db);
-		db->busy = true;
-
-		UseIsolate;
-		v8::String::Utf8Value utf8(isolate, source);
-		const char* sql = *utf8;
-		const char* tail;
-
-		int status;
-		const bool has_logger = db->has_logger;
-		sqlite3* const db_handle = db->db_handle;
-		sqlite3_stmt* handle;
-
-		for (;;) {
-			while (IS_SKIPPED(*sql)) ++sql;
-			status = sqlite3_prepare_v2(db_handle, sql, -1, &handle, &tail);
-			sql = tail;
-			if (!handle) break;
-			if (has_logger && db->Log(isolate, handle)) {
-				sqlite3_finalize(handle);
-				status = -1;
-				break;
-			}
-			do status = sqlite3_step(handle);
-			while (status == SQLITE_ROW);
-			status = sqlite3_finalize(handle);
-			if (status != SQLITE_OK) break;
-		}
-
-		db->busy = false;
-		if (status != SQLITE_OK) {
-			db->ThrowDatabaseError();
-		}
-	}
-
-	NODE_METHOD(JS_backup) {
-		REQUIRE_ARGUMENT_OBJECT(first, v8::Local<v8::Object> database);
-		REQUIRE_ARGUMENT_STRING(second, v8::Local<v8::String> attachedName);
-		REQUIRE_ARGUMENT_STRING(third, v8::Local<v8::String> destFile);
-		REQUIRE_ARGUMENT_BOOLEAN(fourth, bool unlink);
-		(void)database;
-		(void)attachedName;
-		(void)destFile;
-		(void)unlink;
-		UseAddon;
-		UseIsolate;
-		v8::Local<v8::Function> c = addon->Backup.Get(isolate);
-		addon->privileged_info = &info;
-		v8::MaybeLocal<v8::Object> maybeBackup = c->NewInstance(OnlyContext, 0, NULL);
-		addon->privileged_info = NULL;
-		if (!maybeBackup.IsEmpty()) info.GetReturnValue().Set(maybeBackup.ToLocalChecked());
-	}
-
-	NODE_METHOD(JS_serialize) {
-		Database* db = Unwrap<Database>(info.This());
-		REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> attachedName);
-		REQUIRE_DATABASE_OPEN(db);
-		REQUIRE_DATABASE_NOT_BUSY(db);
-		REQUIRE_DATABASE_NO_ITERATORS(db);
-
-		UseIsolate;
-		v8::String::Utf8Value attached_name(isolate, attachedName);
-		sqlite3_int64 length = -1;
-		unsigned char* data = sqlite3_serialize(db->db_handle, *attached_name, &length, 0);
-
-		if (!data && length) {
-			ThrowError("Out of memory");
-			return;
-		}
-
-		info.GetReturnValue().Set(
-			SAFE_NEW_BUFFER(isolate, reinterpret_cast<char*>(data), length, FreeSerialization, NULL).ToLocalChecked()
-		);
-	}
-
-	NODE_METHOD(JS_function) {
-		Database* db = Unwrap<Database>(info.This());
-		REQUIRE_ARGUMENT_FUNCTION(first, v8::Local<v8::Function> fn);
-		REQUIRE_ARGUMENT_STRING(second, v8::Local<v8::String> nameString);
-		REQUIRE_ARGUMENT_INT32(third, int argc);
-		REQUIRE_ARGUMENT_INT32(fourth, int safe_ints);
-		REQUIRE_ARGUMENT_BOOLEAN(fifth, bool deterministic);
-		REQUIRE_ARGUMENT_BOOLEAN(sixth, bool direct_only);
-		REQUIRE_DATABASE_OPEN(db);
-		REQUIRE_DATABASE_NOT_BUSY(db);
-		REQUIRE_DATABASE_NO_ITERATORS(db);
-
-		UseIsolate;
-		v8::String::Utf8Value name(isolate, nameString);
-		int mask = SQLITE_UTF8;
-		if (deterministic) mask |= SQLITE_DETERMINISTIC;
-		if (direct_only) mask |= SQLITE_DIRECTONLY;
-		safe_ints = safe_ints < 2 ? safe_ints : static_cast<int>(db->safe_ints);
-
-		if (sqlite3_create_function_v2(db->db_handle, *name, argc, mask, new CustomFunction(isolate, db, *name, fn, safe_ints), CustomFunction::xFunc, NULL, NULL, CustomFunction::xDestroy) != SQLITE_OK) {
-			db->ThrowDatabaseError();
-		}
-	}
-
-	NODE_METHOD(JS_aggregate) {
-		Database* db = Unwrap<Database>(info.This());
-		REQUIRE_ARGUMENT_ANY(first, v8::Local<v8::Value> start);
-		REQUIRE_ARGUMENT_FUNCTION(second, v8::Local<v8::Function> step);
-		REQUIRE_ARGUMENT_ANY(third, v8::Local<v8::Value> inverse);
-		REQUIRE_ARGUMENT_ANY(fourth, v8::Local<v8::Value> result);
-		REQUIRE_ARGUMENT_STRING(fifth, v8::Local<v8::String> nameString);
-		REQUIRE_ARGUMENT_INT32(sixth, int argc);
-		REQUIRE_ARGUMENT_INT32(seventh, int safe_ints);
-		REQUIRE_ARGUMENT_BOOLEAN(eighth, bool deterministic);
-		REQUIRE_ARGUMENT_BOOLEAN(ninth, bool direct_only);
-		REQUIRE_DATABASE_OPEN(db);
-		REQUIRE_DATABASE_NOT_BUSY(db);
-		REQUIRE_DATABASE_NO_ITERATORS(db);
-
-		UseIsolate;
-		v8::String::Utf8Value name(isolate, nameString);
-		auto xInverse = inverse->IsFunction() ? CustomAggregate::xInverse : NULL;
-		auto xValue = xInverse ? CustomAggregate::xValue : NULL;
-		int mask = SQLITE_UTF8;
-		if (deterministic) mask |= SQLITE_DETERMINISTIC;
-		if (direct_only) mask |= SQLITE_DIRECTONLY;
-		safe_ints = safe_ints < 2 ? safe_ints : static_cast<int>(db->safe_ints);
-
-		if (sqlite3_create_window_function(db->db_handle, *name, argc, mask, new CustomAggregate(isolate, db, *name, start, step, inverse, result, safe_ints), CustomAggregate::xStep, CustomAggregate::xFinal, xValue, xInverse, CustomAggregate::xDestroy) != SQLITE_OK) {
-			db->ThrowDatabaseError();
-		}
-	}
-
-	NODE_METHOD(JS_table) {
-		Database* db = Unwrap<Database>(info.This());
-		REQUIRE_ARGUMENT_FUNCTION(first, v8::Local<v8::Function> factory);
-		REQUIRE_ARGUMENT_STRING(second, v8::Local<v8::String> nameString);
-		REQUIRE_ARGUMENT_BOOLEAN(third, bool eponymous);
-		REQUIRE_DATABASE_OPEN(db);
-		REQUIRE_DATABASE_NOT_BUSY(db);
-		REQUIRE_DATABASE_NO_ITERATORS(db);
-
-		UseIsolate;
-		v8::String::Utf8Value name(isolate, nameString);
-		sqlite3_module* module = eponymous ? &CustomTable::EPONYMOUS_MODULE : &CustomTable::MODULE;
-
-		db->busy = true;
-		if (sqlite3_create_module_v2(db->db_handle, *name, module, new CustomTable(isolate, db, *name, factory), CustomTable::Destructor) != SQLITE_OK) {
-			db->ThrowDatabaseError();
-		}
-		db->busy = false;
-	}
-
-	NODE_METHOD(JS_loadExtension) {
-		Database* db = Unwrap<Database>(info.This());
-		v8::Local<v8::String> entryPoint;
-		REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> filename);
-		if (info.Length() > 1) { REQUIRE_ARGUMENT_STRING(second, entryPoint); }
-		REQUIRE_DATABASE_OPEN(db);
-		REQUIRE_DATABASE_NOT_BUSY(db);
-		REQUIRE_DATABASE_NO_ITERATORS(db);
-		UseIsolate;
-		char* error;
-		int status = sqlite3_load_extension(
-			db->db_handle,
-			*v8::String::Utf8Value(isolate, filename),
-			entryPoint.IsEmpty() ? NULL : *v8::String::Utf8Value(isolate, entryPoint),
-			&error
-		);
-		if (status != SQLITE_OK) {
-			ThrowSqliteError(db->addon, error, status);
-		}
-		sqlite3_free(error);
-	}
-
-	NODE_METHOD(JS_close) {
-		Database* db = Unwrap<Database>(info.This());
-		if (db->open) {
-			REQUIRE_DATABASE_NOT_BUSY(db);
-			REQUIRE_DATABASE_NO_ITERATORS(db);
-			db->addon->dbs.erase(db);
-			db->CloseHandles();
-		}
-	}
-
-	NODE_METHOD(JS_defaultSafeIntegers) {
-		Database* db = Unwrap<Database>(info.This());
-		if (info.Length() == 0) db->safe_ints = true;
-		else { REQUIRE_ARGUMENT_BOOLEAN(first, db->safe_ints); }
-	}
-
-	NODE_METHOD(JS_unsafeMode) {
-		Database* db = Unwrap<Database>(info.This());
-		if (info.Length() == 0) db->unsafe_mode = true;
-		else { REQUIRE_ARGUMENT_BOOLEAN(first, db->unsafe_mode); }
-		sqlite3_db_config(db->db_handle, SQLITE_DBCONFIG_DEFENSIVE, static_cast<int>(!db->unsafe_mode), NULL);
-	}
-
-	NODE_GETTER(JS_open) {
-		info.GetReturnValue().Set(Unwrap<Database>(info.This())->open);
-	}
-
-	NODE_GETTER(JS_inTransaction) {
-		Database* db = Unwrap<Database>(info.This());
-		info.GetReturnValue().Set(db->open && !static_cast<bool>(sqlite3_get_autocommit(db->db_handle)));
-	}
-
-	static bool Deserialize(v8::Local<v8::Object> buffer, Addon* addon, sqlite3* db_handle, bool readonly) {
-		size_t length = node::Buffer::Length(buffer);
-		unsigned char* data = (unsigned char*)sqlite3_malloc64(length);
-		unsigned int flags = SQLITE_DESERIALIZE_FREEONCLOSE | SQLITE_DESERIALIZE_RESIZEABLE;
-
-		if (readonly) {
-			flags |= SQLITE_DESERIALIZE_READONLY;
-		}
-		if (length) {
-			if (!data) {
-				ThrowError("Out of memory");
-				return false;
-			}
-			memcpy(data, node::Buffer::Data(buffer), length);
-		}
-
-		int status = sqlite3_deserialize(db_handle, "main", data, length, length, flags);
-		if (status != SQLITE_OK) {
-			ThrowSqliteError(addon, status == SQLITE_ERROR ? "unable to deserialize database" : sqlite3_errstr(status), status);
-			return false;
-		}
-
-		return true;
-	}
-
-	static void FreeSerialization(char* data, void* _) {
-		sqlite3_free(data);
-	}
-
-	static const int MAX_BUFFER_SIZE = node::Buffer::kMaxLength > INT_MAX ? INT_MAX : static_cast<int>(node::Buffer::kMaxLength);
-	static const int MAX_STRING_SIZE = v8::String::kMaxLength > INT_MAX ? INT_MAX : static_cast<int>(v8::String::kMaxLength);
-
-	sqlite3* const db_handle;
-	bool open;
-	bool busy;
-	bool safe_ints;
-	bool unsafe_mode;
-	bool was_js_error;
-	const bool has_logger;
-	unsigned short iterators;
-	Addon* const addon;
-	const v8::Global<v8::Value> logger;
-	std::set<Statement*, CompareStatement> stmts;
-	std::set<Backup*, CompareBackup> backups;
-};

src/objects/statement-iterator.cpp

@@ -0,0 +1,113 @@
+StatementIterator::StatementIterator(Statement* stmt, bool bound) :
+	node::ObjectWrap(),
+	stmt(stmt),
+	handle(stmt->handle),
+	db_state(stmt->db->GetState()),
+	bound(bound),
+	safe_ints(stmt->safe_ints),
+	mode(stmt->mode),
+	alive(true),
+	logged(!db_state->has_logger) {
+	assert(stmt != NULL);
+	assert(handle != NULL);
+	assert(stmt->bound == bound);
+	assert(stmt->alive == true);
+	assert(stmt->locked == false);
+	assert(db_state->iterators < USHRT_MAX);
+	stmt->locked = true;
+	db_state->iterators += 1;
+}
+
+// The ~Statement destructor currently covers any state this object creates.
+// Additionally, we actually DON'T want to revert stmt->locked or db_state
+// ->iterators in this destructor, to ensure deterministic database access.
+StatementIterator::~StatementIterator() {}
+
+void StatementIterator::Next(NODE_ARGUMENTS info) {
+	assert(alive == true);
+	db_state->busy = true;
+	if (!logged) {
+		logged = true;
+		if (stmt->db->Log(OnlyIsolate, handle)) {
+			db_state->busy = false;
+			Throw();
+			return;
+		}
+	}
+	int status = sqlite3_step(handle);
+	db_state->busy = false;
+	if (status == SQLITE_ROW) {
+		UseIsolate;
+		UseContext;
+		info.GetReturnValue().Set(
+			NewRecord(isolate, ctx, Data::GetRowJS(isolate, ctx, handle, safe_ints, mode), db_state->addon, false)
+		);
+	} else {
+		if (status == SQLITE_DONE) Return(info);
+		else Throw();
+	}
+}
+
+void StatementIterator::Return(NODE_ARGUMENTS info) {
+	Cleanup();
+	STATEMENT_RETURN_LOGIC(DoneRecord(OnlyIsolate, db_state->addon));
+}
+
+void StatementIterator::Throw() {
+	Cleanup();
+	Database* db = stmt->db;
+	STATEMENT_THROW_LOGIC();
+}
+
+void StatementIterator::Cleanup() {
+	assert(alive == true);
+	alive = false;
+	stmt->locked = false;
+	db_state->iterators -= 1;
+	sqlite3_reset(handle);
+}
+
+INIT(StatementIterator::Init) {
+	v8::Local<v8::FunctionTemplate> t = NewConstructorTemplate(isolate, data, JS_new, "StatementIterator");
+	SetPrototypeMethod(isolate, data, t, "next", JS_next);
+	SetPrototypeMethod(isolate, data, t, "return", JS_return);
+	SetPrototypeSymbolMethod(isolate, data, t, v8::Symbol::GetIterator(isolate), JS_symbolIterator);
+	return t->GetFunction(OnlyContext).ToLocalChecked();
+}
+
+NODE_METHOD(StatementIterator::JS_new) {
+	UseAddon;
+	if (!addon->privileged_info) return ThrowTypeError("Disabled constructor");
+	assert(info.IsConstructCall());
+
+	StatementIterator* iter;
+	{
+		NODE_ARGUMENTS info = *addon->privileged_info;
+		STATEMENT_START_LOGIC(REQUIRE_STATEMENT_RETURNS_DATA, DOES_ADD_ITERATOR);
+		iter = new StatementIterator(stmt, bound);
+	}
+	UseIsolate;
+	UseContext;
+	iter->Wrap(info.This());
+	SetFrozen(isolate, ctx, info.This(), addon->cs.statement, addon->privileged_info->This());
+
+	info.GetReturnValue().Set(info.This());
+}
+
+NODE_METHOD(StatementIterator::JS_next) {
+	StatementIterator* iter = Unwrap<StatementIterator>(info.This());
+	REQUIRE_DATABASE_NOT_BUSY(iter->db_state);
+	if (iter->alive) iter->Next(info);
+	else info.GetReturnValue().Set(DoneRecord(OnlyIsolate, iter->db_state->addon));
+}
+
+NODE_METHOD(StatementIterator::JS_return) {
+	StatementIterator* iter = Unwrap<StatementIterator>(info.This());
+	REQUIRE_DATABASE_NOT_BUSY(iter->db_state);
+	if (iter->alive) iter->Return(info);
+	else info.GetReturnValue().Set(DoneRecord(OnlyIsolate, iter->db_state->addon));
+}
+
+NODE_METHOD(StatementIterator::JS_symbolIterator) {
+	info.GetReturnValue().Set(info.This());
+}

src/objects/statement-iterator.hpp

@@ -0,0 +1,50 @@
+class StatementIterator : public node::ObjectWrap {
+public:
+
+	// The ~Statement destructor currently covers any state this object creates.
+	// Additionally, we actually DON'T want to revert stmt->locked or db_state
+	// ->iterators in this destructor, to ensure deterministic database access.
+	~StatementIterator();
+
+	static INIT(Init);
+
+private:
+
+	explicit StatementIterator(Statement* stmt, bool bound);
+
+	void Next(NODE_ARGUMENTS info);
+	void Return(NODE_ARGUMENTS info);
+	void Throw();
+	void Cleanup();
+
+	static inline v8::Local<v8::Object> NewRecord(
+		v8::Isolate* isolate,
+		v8::Local<v8::Context> ctx,
+		v8::Local<v8::Value> value,
+		Addon* addon,
+		bool done
+	) {
+		v8::Local<v8::Object> record = v8::Object::New(isolate);
+		record->Set(ctx, addon->cs.value.Get(isolate), value).FromJust();
+		record->Set(ctx, addon->cs.done.Get(isolate), v8::Boolean::New(isolate, done)).FromJust();
+		return record;
+	}
+
+	static inline v8::Local<v8::Object> DoneRecord(v8::Isolate* isolate, Addon* addon) {
+		return NewRecord(isolate, OnlyContext, v8::Undefined(isolate), addon, true);
+	}
+
+	static NODE_METHOD(JS_new);
+	static NODE_METHOD(JS_next);
+	static NODE_METHOD(JS_return);
+	static NODE_METHOD(JS_symbolIterator);
+
+	Statement* const stmt;
+	sqlite3_stmt* const handle;
+	Database::State* const db_state;
+	const bool bound;
+	const bool safe_ints;
+	const char mode;
+	bool alive;
+	bool logged;
+};

src/objects/statement-iterator.lzz

@@ -1,138 +0,0 @@
-class StatementIterator : public node::ObjectWrap {
-public:
-
-	INIT(Init) {
-		v8::Local<v8::FunctionTemplate> t = NewConstructorTemplate(isolate, data, JS_new, "StatementIterator");
-		SetPrototypeMethod(isolate, data, t, "next", JS_next);
-		SetPrototypeMethod(isolate, data, t, "return", JS_return);
-		SetPrototypeSymbolMethod(isolate, data, t, v8::Symbol::GetIterator(isolate), JS_symbolIterator);
-		return t->GetFunction(OnlyContext).ToLocalChecked();
-	}
-
-	// The ~Statement destructor currently covers any state this object creates.
-	// Additionally, we actually DON'T want to revert stmt->locked or db_state
-	// ->iterators in this destructor, to ensure deterministic database access.
-	~StatementIterator() {}
-
-private:
-
-	explicit StatementIterator(Statement* stmt, bool bound) : node::ObjectWrap(),
-		stmt(stmt),
-		handle(stmt->handle),
-		db_state(stmt->db->GetState()),
-		bound(bound),
-		safe_ints(stmt->safe_ints),
-		mode(stmt->mode),
-		alive(true),
-		logged(!db_state->has_logger) {
-		assert(stmt != NULL);
-		assert(handle != NULL);
-		assert(stmt->bound == bound);
-		assert(stmt->alive == true);
-		assert(stmt->locked == false);
-		assert(db_state->iterators < USHRT_MAX);
-		stmt->locked = true;
-		db_state->iterators += 1;
-	}
-
-	NODE_METHOD(JS_new) {
-		UseAddon;
-		if (!addon->privileged_info) return ThrowTypeError("Disabled constructor");
-		assert(info.IsConstructCall());
-
-		StatementIterator* iter;
-		{
-			NODE_ARGUMENTS info = *addon->privileged_info;
-			STATEMENT_START_LOGIC(REQUIRE_STATEMENT_RETURNS_DATA, DOES_ADD_ITERATOR);
-			iter = new StatementIterator(stmt, bound);
-		}
-		UseIsolate;
-		UseContext;
-		iter->Wrap(info.This());
-		SetFrozen(isolate, ctx, info.This(), addon->cs.statement, addon->privileged_info->This());
-
-		info.GetReturnValue().Set(info.This());
-	}
-
-	NODE_METHOD(JS_next) {
-		StatementIterator* iter = Unwrap<StatementIterator>(info.This());
-		REQUIRE_DATABASE_NOT_BUSY(iter->db_state);
-		if (iter->alive) iter->Next(info);
-		else info.GetReturnValue().Set(DoneRecord(OnlyIsolate, iter->db_state->addon));
-	}
-
-	NODE_METHOD(JS_return) {
-		StatementIterator* iter = Unwrap<StatementIterator>(info.This());
-		REQUIRE_DATABASE_NOT_BUSY(iter->db_state);
-		if (iter->alive) iter->Return(info);
-		else info.GetReturnValue().Set(DoneRecord(OnlyIsolate, iter->db_state->addon));
-	}
-
-	NODE_METHOD(JS_symbolIterator) {
-		info.GetReturnValue().Set(info.This());
-	}
-
-	void Next(NODE_ARGUMENTS info) {
-		assert(alive == true);
-		db_state->busy = true;
-		if (!logged) {
-			logged = true;
-			if (stmt->db->Log(OnlyIsolate, handle)) {
-				db_state->busy = false;
-				Throw();
-				return;
-			}
-		}
-		int status = sqlite3_step(handle);
-		db_state->busy = false;
-		if (status == SQLITE_ROW) {
-			UseIsolate;
-			UseContext;
-			info.GetReturnValue().Set(
-				NewRecord(isolate, ctx, Data::GetRowJS(isolate, ctx, handle, safe_ints, mode), db_state->addon, false)
-			);
-		} else {
-			if (status == SQLITE_DONE) Return(info);
-			else Throw();
-		}
-	}
-
-	void Return(NODE_ARGUMENTS info) {
-		Cleanup();
-		STATEMENT_RETURN_LOGIC(DoneRecord(OnlyIsolate, db_state->addon));
-	}
-
-	void Throw() {
-		Cleanup();
-		Database* db = stmt->db;
-		STATEMENT_THROW_LOGIC();
-	}
-
-	void Cleanup() {
-		assert(alive == true);
-		alive = false;
-		stmt->locked = false;
-		db_state->iterators -= 1;
-		sqlite3_reset(handle);
-	}
-
-	static inline v8::Local<v8::Object> NewRecord(v8::Isolate* isolate, v8::Local<v8::Context> ctx, v8::Local<v8::Value> value, Addon* addon, bool done) {
-		v8::Local<v8::Object> record = v8::Object::New(isolate);
-		record->Set(ctx, addon->cs.value.Get(isolate), value).FromJust();
-		record->Set(ctx, addon->cs.done.Get(isolate), v8::Boolean::New(isolate, done)).FromJust();
-		return record;
-	}
-
-	static inline v8::Local<v8::Object> DoneRecord(v8::Isolate* isolate, Addon* addon) {
-		return NewRecord(isolate, OnlyContext, v8::Undefined(isolate), addon, true);
-	}
-
-	Statement* const stmt;
-	sqlite3_stmt* const handle;
-	Database::State* const db_state;
-	const bool bound;
-	const bool safe_ints;
-	const char mode;
-	bool alive;
-	bool logged;
-};

src/objects/statement.cpp

@@ -0,0 +1,310 @@
+Statement::Statement(
+	Database* db,
+	sqlite3_stmt* handle,
+	sqlite3_uint64 id,
+	bool returns_data
+) :
+	node::ObjectWrap(),
+	db(db),
+	handle(handle),
+	extras(new Extras(id)),
+	alive(true),
+	locked(false),
+	bound(false),
+	has_bind_map(false),
+	safe_ints(db->GetState()->safe_ints),
+	mode(Data::FLAT),
+	returns_data(returns_data) {
+	assert(db != NULL);
+	assert(handle != NULL);
+	assert(db->GetState()->open);
+	assert(!db->GetState()->busy);
+	db->AddStatement(this);
+}
+
+Statement::~Statement() {
+	if (alive) db->RemoveStatement(this);
+	CloseHandles();
+	delete extras;
+}
+
+// Whenever this is used, db->RemoveStatement must be invoked beforehand.
+void Statement::CloseHandles() {
+	if (alive) {
+		alive = false;
+		sqlite3_finalize(handle);
+	}
+}
+
+// Returns the Statement's bind map (creates it upon first execution).
+BindMap* Statement::GetBindMap(v8::Isolate* isolate) {
+	if (has_bind_map) return &extras->bind_map;
+	BindMap* bind_map = &extras->bind_map;
+	int param_count = sqlite3_bind_parameter_count(handle);
+	for (int i = 1; i <= param_count; ++i) {
+		const char* name = sqlite3_bind_parameter_name(handle, i);
+		if (name != NULL) bind_map->Add(isolate, name + 1, i);
+	}
+	has_bind_map = true;
+	return bind_map;
+}
+
+Statement::Extras::Extras(sqlite3_uint64 id)
+	: bind_map(0), id(id) {}
+
+INIT(Statement::Init) {
+	v8::Local<v8::FunctionTemplate> t = NewConstructorTemplate(isolate, data, JS_new, "Statement");
+	SetPrototypeMethod(isolate, data, t, "run", JS_run);
+	SetPrototypeMethod(isolate, data, t, "get", JS_get);
+	SetPrototypeMethod(isolate, data, t, "all", JS_all);
+	SetPrototypeMethod(isolate, data, t, "iterate", JS_iterate);
+	SetPrototypeMethod(isolate, data, t, "bind", JS_bind);
+	SetPrototypeMethod(isolate, data, t, "pluck", JS_pluck);
+	SetPrototypeMethod(isolate, data, t, "expand", JS_expand);
+	SetPrototypeMethod(isolate, data, t, "raw", JS_raw);
+	SetPrototypeMethod(isolate, data, t, "safeIntegers", JS_safeIntegers);
+	SetPrototypeMethod(isolate, data, t, "columns", JS_columns);
+	SetPrototypeGetter(isolate, data, t, "busy", JS_busy);
+	return t->GetFunction(OnlyContext).ToLocalChecked();
+}
+
+NODE_METHOD(Statement::JS_new) {
+	UseAddon;
+	if (!addon->privileged_info) {
+		return ThrowTypeError("Statements can only be constructed by the db.prepare() method");
+	}
+	assert(info.IsConstructCall());
+	Database* db = Unwrap<Database>(addon->privileged_info->This());
+	REQUIRE_DATABASE_OPEN(db->GetState());
+	REQUIRE_DATABASE_NOT_BUSY(db->GetState());
+
+	v8::Local<v8::String> source = (*addon->privileged_info)[0].As<v8::String>();
+	v8::Local<v8::Object> database = (*addon->privileged_info)[1].As<v8::Object>();
+	bool pragmaMode = (*addon->privileged_info)[2].As<v8::Boolean>()->Value();
+	int flags = SQLITE_PREPARE_PERSISTENT;
+
+	if (pragmaMode) {
+		REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db->GetState());
+		flags = 0;
+	}
+
+	UseIsolate;
+	v8::String::Utf8Value utf8(isolate, source);
+	sqlite3_stmt* handle;
+	const char* tail;
+
+	if (sqlite3_prepare_v3(db->GetHandle(), *utf8, utf8.length() + 1, flags, &handle, &tail) != SQLITE_OK) {
+		return db->ThrowDatabaseError();
+	}
+	if (handle == NULL) {
+		return ThrowRangeError("The supplied SQL string contains no statements");
+	}
+	// https://github.com/WiseLibs/better-sqlite3/issues/975#issuecomment-1520934678
+	for (char c; (c = *tail); ) {
+		if (IS_SKIPPED(c)) {
+			++tail;
+			continue;
+		}
+		if (c == '/' && tail[1] == '*') {
+			tail += 2;
+			for (char c; (c = *tail); ++tail) {
+				if (c == '*' && tail[1] == '/') {
+					tail += 2;
+					break;
+				}
+			}
+		} else if (c == '-' && tail[1] == '-') {
+			tail += 2;
+			for (char c; (c = *tail); ++tail) {
+				if (c == '\n') {
+					++tail;
+					break;
+				}
+			}
+		} else {
+			sqlite3_finalize(handle);
+			return ThrowRangeError("The supplied SQL string contains more than one statement");
+		}
+	}
+
+	UseContext;
+	bool returns_data = sqlite3_column_count(handle) >= 1 || pragmaMode;
+	Statement* stmt = new Statement(db, handle, addon->NextId(), returns_data);
+	stmt->Wrap(info.This());
+	SetFrozen(isolate, ctx, info.This(), addon->cs.reader, v8::Boolean::New(isolate, returns_data));
+	SetFrozen(isolate, ctx, info.This(), addon->cs.readonly, v8::Boolean::New(isolate, sqlite3_stmt_readonly(handle) != 0));
+	SetFrozen(isolate, ctx, info.This(), addon->cs.source, source);
+	SetFrozen(isolate, ctx, info.This(), addon->cs.database, database);
+
+	info.GetReturnValue().Set(info.This());
+}
+
+NODE_METHOD(Statement::JS_run) {
+	STATEMENT_START(ALLOW_ANY_STATEMENT, DOES_MUTATE);
+	sqlite3* db_handle = db->GetHandle();
+	int total_changes_before = sqlite3_total_changes(db_handle);
+
+	sqlite3_step(handle);
+	if (sqlite3_reset(handle) == SQLITE_OK) {
+		int changes = sqlite3_total_changes(db_handle) == total_changes_before ? 0 : sqlite3_changes(db_handle);
+		sqlite3_int64 id = sqlite3_last_insert_rowid(db_handle);
+		Addon* addon = db->GetAddon();
+		UseContext;
+		v8::Local<v8::Object> result = v8::Object::New(isolate);
+		result->Set(ctx, addon->cs.changes.Get(isolate), v8::Int32::New(isolate, changes)).FromJust();
+		result->Set(ctx, addon->cs.lastInsertRowid.Get(isolate),
+			stmt->safe_ints
+				? v8::BigInt::New(isolate, id).As<v8::Value>()
+				: v8::Number::New(isolate, (double)id).As<v8::Value>()
+		).FromJust();
+		STATEMENT_RETURN(result);
+	}
+	STATEMENT_THROW();
+}
+
+NODE_METHOD(Statement::JS_get) {
+	STATEMENT_START(REQUIRE_STATEMENT_RETURNS_DATA, DOES_NOT_MUTATE);
+	int status = sqlite3_step(handle);
+	if (status == SQLITE_ROW) {
+		v8::Local<v8::Value> result = Data::GetRowJS(isolate, OnlyContext, handle, stmt->safe_ints, stmt->mode);
+		sqlite3_reset(handle);
+		STATEMENT_RETURN(result);
+	} else if (status == SQLITE_DONE) {
+		sqlite3_reset(handle);
+		STATEMENT_RETURN(v8::Undefined(isolate));
+	}
+	sqlite3_reset(handle);
+	STATEMENT_THROW();
+}
+
+NODE_METHOD(Statement::JS_all) {
+	STATEMENT_START(REQUIRE_STATEMENT_RETURNS_DATA, DOES_NOT_MUTATE);
+	UseContext;
+	v8::Local<v8::Array> result = v8::Array::New(isolate, 0);
+	uint32_t row_count = 0;
+	const bool safe_ints = stmt->safe_ints;
+	const char mode = stmt->mode;
+	bool js_error = false;
+
+	while (sqlite3_step(handle) == SQLITE_ROW) {
+		if (row_count == 0xffffffff) { ThrowRangeError("Array overflow (too many rows returned)"); js_error = true; break; }
+		result->Set(ctx, row_count++, Data::GetRowJS(isolate, ctx, handle, safe_ints, mode)).FromJust();
+	}
+
+	if (sqlite3_reset(handle) == SQLITE_OK && !js_error) {
+		STATEMENT_RETURN(result);
+	}
+	if (js_error) db->GetState()->was_js_error = true;
+	STATEMENT_THROW();
+}
+
+NODE_METHOD(Statement::JS_iterate) {
+	UseAddon;
+	UseIsolate;
+	v8::Local<v8::Function> c = addon->StatementIterator.Get(isolate);
+	addon->privileged_info = &info;
+	v8::MaybeLocal<v8::Object> maybeIterator = c->NewInstance(OnlyContext, 0, NULL);
+	addon->privileged_info = NULL;
+	if (!maybeIterator.IsEmpty()) info.GetReturnValue().Set(maybeIterator.ToLocalChecked());
+}
+
+NODE_METHOD(Statement::JS_bind) {
+	Statement* stmt = Unwrap<Statement>(info.This());
+	if (stmt->bound) return ThrowTypeError("The bind() method can only be invoked once per statement object");
+	REQUIRE_DATABASE_OPEN(stmt->db->GetState());
+	REQUIRE_DATABASE_NOT_BUSY(stmt->db->GetState());
+	REQUIRE_STATEMENT_NOT_LOCKED(stmt);
+	STATEMENT_BIND(stmt->handle);
+	stmt->bound = true;
+	info.GetReturnValue().Set(info.This());
+}
+
+NODE_METHOD(Statement::JS_pluck) {
+	Statement* stmt = Unwrap<Statement>(info.This());
+	if (!stmt->returns_data) return ThrowTypeError("The pluck() method is only for statements that return data");
+	REQUIRE_DATABASE_NOT_BUSY(stmt->db->GetState());
+	REQUIRE_STATEMENT_NOT_LOCKED(stmt);
+	bool use = true;
+	if (info.Length() != 0) { REQUIRE_ARGUMENT_BOOLEAN(first, use); }
+	stmt->mode = use ? Data::PLUCK : stmt->mode == Data::PLUCK ? Data::FLAT : stmt->mode;
+	info.GetReturnValue().Set(info.This());
+}
+
+NODE_METHOD(Statement::JS_expand) {
+	Statement* stmt = Unwrap<Statement>(info.This());
+	if (!stmt->returns_data) return ThrowTypeError("The expand() method is only for statements that return data");
+	REQUIRE_DATABASE_NOT_BUSY(stmt->db->GetState());
+	REQUIRE_STATEMENT_NOT_LOCKED(stmt);
+	bool use = true;
+	if (info.Length() != 0) { REQUIRE_ARGUMENT_BOOLEAN(first, use); }
+	stmt->mode = use ? Data::EXPAND : stmt->mode == Data::EXPAND ? Data::FLAT : stmt->mode;
+	info.GetReturnValue().Set(info.This());
+}
+
+NODE_METHOD(Statement::JS_raw) {
+	Statement* stmt = Unwrap<Statement>(info.This());
+	if (!stmt->returns_data) return ThrowTypeError("The raw() method is only for statements that return data");
+	REQUIRE_DATABASE_NOT_BUSY(stmt->db->GetState());
+	REQUIRE_STATEMENT_NOT_LOCKED(stmt);
+	bool use = true;
+	if (info.Length() != 0) { REQUIRE_ARGUMENT_BOOLEAN(first, use); }
+	stmt->mode = use ? Data::RAW : stmt->mode == Data::RAW ? Data::FLAT : stmt->mode;
+	info.GetReturnValue().Set(info.This());
+}
+
+NODE_METHOD(Statement::JS_safeIntegers) {
+	Statement* stmt = Unwrap<Statement>(info.This());
+	REQUIRE_DATABASE_NOT_BUSY(stmt->db->GetState());
+	REQUIRE_STATEMENT_NOT_LOCKED(stmt);
+	if (info.Length() == 0) stmt->safe_ints = true;
+	else { REQUIRE_ARGUMENT_BOOLEAN(first, stmt->safe_ints); }
+	info.GetReturnValue().Set(info.This());
+}
+
+NODE_METHOD(Statement::JS_columns) {
+	Statement* stmt = Unwrap<Statement>(info.This());
+	if (!stmt->returns_data) return ThrowTypeError("The columns() method is only for statements that return data");
+	REQUIRE_DATABASE_OPEN(stmt->db->GetState());
+	REQUIRE_DATABASE_NOT_BUSY(stmt->db->GetState());
+	Addon* addon = stmt->db->GetAddon();
+	UseIsolate;
+	UseContext;
+
+	int column_count = sqlite3_column_count(stmt->handle);
+	v8::Local<v8::Array> columns = v8::Array::New(isolate);
+
+	v8::Local<v8::String> name = addon->cs.name.Get(isolate);
+	v8::Local<v8::String> columnName = addon->cs.column.Get(isolate);
+	v8::Local<v8::String> tableName = addon->cs.table.Get(isolate);
+	v8::Local<v8::String> databaseName = addon->cs.database.Get(isolate);
+	v8::Local<v8::String> typeName = addon->cs.type.Get(isolate);
+
+	for (int i = 0; i < column_count; ++i) {
+		v8::Local<v8::Object> column = v8::Object::New(isolate);
+
+		column->Set(ctx, name,
+			InternalizedFromUtf8OrNull(isolate, sqlite3_column_name(stmt->handle, i), -1)
+		).FromJust();
+		column->Set(ctx, columnName,
+			InternalizedFromUtf8OrNull(isolate, sqlite3_column_origin_name(stmt->handle, i), -1)
+		).FromJust();
+		column->Set(ctx, tableName,
+			InternalizedFromUtf8OrNull(isolate, sqlite3_column_table_name(stmt->handle, i), -1)
+		).FromJust();
+		column->Set(ctx, databaseName,
+			InternalizedFromUtf8OrNull(isolate, sqlite3_column_database_name(stmt->handle, i), -1)
+		).FromJust();
+		column->Set(ctx, typeName,
+			InternalizedFromUtf8OrNull(isolate, sqlite3_column_decltype(stmt->handle, i), -1)
+		).FromJust();
+
+		columns->Set(ctx, i, column).FromJust();
+	}
+
+	info.GetReturnValue().Set(columns);
+}
+
+NODE_GETTER(Statement::JS_busy) {
+	Statement* stmt = Unwrap<Statement>(info.This());
+	info.GetReturnValue().Set(stmt->alive && stmt->locked);
+}

src/objects/statement.hpp

@@ -0,0 +1,58 @@
+class Statement : public node::ObjectWrap { friend class StatementIterator;
+public:
+
+	~Statement();
+
+	// Whenever this is used, db->RemoveStatement must be invoked beforehand.
+	void CloseHandles();
+
+	// Used to support ordered containers.
+	static inline bool Compare(Statement const * const a, Statement const * const b) {
+		return a->extras->id < b->extras->id;
+	}
+
+	// Returns the Statement's bind map (creates it upon first execution).
+	BindMap* GetBindMap(v8::Isolate* isolate);
+
+	static INIT(Init);
+
+private:
+
+	// A class for holding values that are less often used.
+	class Extras { friend class Statement;
+		explicit Extras(sqlite3_uint64 id);
+		BindMap bind_map;
+		const sqlite3_uint64 id;
+	};
+
+	explicit Statement(
+		Database* db,
+		sqlite3_stmt* handle,
+		sqlite3_uint64 id,
+		bool returns_data
+	);
+
+	static NODE_METHOD(JS_new);
+	static NODE_METHOD(JS_run);
+	static NODE_METHOD(JS_get);
+	static NODE_METHOD(JS_all);
+	static NODE_METHOD(JS_iterate);
+	static NODE_METHOD(JS_bind);
+	static NODE_METHOD(JS_pluck);
+	static NODE_METHOD(JS_expand);
+	static NODE_METHOD(JS_raw);
+	static NODE_METHOD(JS_safeIntegers);
+	static NODE_METHOD(JS_columns);
+	static NODE_GETTER(JS_busy);
+
+	Database* const db;
+	sqlite3_stmt* const handle;
+	Extras* const extras;
+	bool alive;
+	bool locked;
+	bool bound;
+	bool has_bind_map;
+	bool safe_ints;
+	char mode;
+	const bool returns_data;
+};

src/objects/statement.lzz

@@ -1,336 +0,0 @@
-class Statement : public node::ObjectWrap { friend class StatementIterator;
-public:
-
-	INIT(Init) {
-		v8::Local<v8::FunctionTemplate> t = NewConstructorTemplate(isolate, data, JS_new, "Statement");
-		SetPrototypeMethod(isolate, data, t, "run", JS_run);
-		SetPrototypeMethod(isolate, data, t, "get", JS_get);
-		SetPrototypeMethod(isolate, data, t, "all", JS_all);
-		SetPrototypeMethod(isolate, data, t, "iterate", JS_iterate);
-		SetPrototypeMethod(isolate, data, t, "bind", JS_bind);
-		SetPrototypeMethod(isolate, data, t, "pluck", JS_pluck);
-		SetPrototypeMethod(isolate, data, t, "expand", JS_expand);
-		SetPrototypeMethod(isolate, data, t, "raw", JS_raw);
-		SetPrototypeMethod(isolate, data, t, "safeIntegers", JS_safeIntegers);
-		SetPrototypeMethod(isolate, data, t, "columns", JS_columns);
-		SetPrototypeGetter(isolate, data, t, "busy", JS_busy);
-		return t->GetFunction(OnlyContext).ToLocalChecked();
-	}
-
-	// Used to support ordered containers.
-	static inline bool Compare(Statement const * const a, Statement const * const b) {
-		return a->extras->id < b->extras->id;
-	}
-
-	// Returns the Statement's bind map (creates it upon first execution).
-	BindMap* GetBindMap(v8::Isolate* isolate) {
-		if (has_bind_map) return &extras->bind_map;
-		BindMap* bind_map = &extras->bind_map;
-		int param_count = sqlite3_bind_parameter_count(handle);
-		for (int i = 1; i <= param_count; ++i) {
-			const char* name = sqlite3_bind_parameter_name(handle, i);
-			if (name != NULL) bind_map->Add(isolate, name + 1, i);
-		}
-		has_bind_map = true;
-		return bind_map;
-	}
-
-	// Whenever this is used, db->RemoveStatement must be invoked beforehand.
-	void CloseHandles() {
-		if (alive) {
-			alive = false;
-			sqlite3_finalize(handle);
-		}
-	}
-
-	~Statement() {
-		if (alive) db->RemoveStatement(this);
-		CloseHandles();
-		delete extras;
-	}
-
-private:
-
-	// A class for holding values that are less often used.
-	class Extras { friend class Statement;
-		explicit Extras(sqlite3_uint64 id) : bind_map(0), id(id) {}
-		BindMap bind_map;
-		const sqlite3_uint64 id;
-	};
-
-	explicit Statement(
-		Database* db,
-		sqlite3_stmt* handle,
-		sqlite3_uint64 id,
-		bool returns_data
-	) :
-		node::ObjectWrap(),
-		db(db),
-		handle(handle),
-		extras(new Extras(id)),
-		alive(true),
-		locked(false),
-		bound(false),
-		has_bind_map(false),
-		safe_ints(db->GetState()->safe_ints),
-		mode(Data::FLAT),
-		returns_data(returns_data) {
-		assert(db != NULL);
-		assert(handle != NULL);
-		assert(db->GetState()->open);
-		assert(!db->GetState()->busy);
-		db->AddStatement(this);
-	}
-
-	NODE_METHOD(JS_new) {
-		UseAddon;
-		if (!addon->privileged_info) {
-			return ThrowTypeError("Statements can only be constructed by the db.prepare() method");
-		}
-		assert(info.IsConstructCall());
-		Database* db = Unwrap<Database>(addon->privileged_info->This());
-		REQUIRE_DATABASE_OPEN(db->GetState());
-		REQUIRE_DATABASE_NOT_BUSY(db->GetState());
-
-		v8::Local<v8::String> source = (*addon->privileged_info)[0].As<v8::String>();
-		v8::Local<v8::Object> database = (*addon->privileged_info)[1].As<v8::Object>();
-		bool pragmaMode = (*addon->privileged_info)[2].As<v8::Boolean>()->Value();
-		int flags = SQLITE_PREPARE_PERSISTENT;
-
-		if (pragmaMode) {
-			REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db->GetState());
-			flags = 0;
-		}
-
-		UseIsolate;
-		v8::String::Utf8Value utf8(isolate, source);
-		sqlite3_stmt* handle;
-		const char* tail;
-
-		if (sqlite3_prepare_v3(db->GetHandle(), *utf8, utf8.length() + 1, flags, &handle, &tail) != SQLITE_OK) {
-			return db->ThrowDatabaseError();
-		}
-		if (handle == NULL) {
-			return ThrowRangeError("The supplied SQL string contains no statements");
-		}
-		// https://github.com/WiseLibs/better-sqlite3/issues/975#issuecomment-1520934678
-		for (char c; (c = *tail); ) {
-			if (IS_SKIPPED(c)) {
-				++tail;
-				continue;
-			}
-			if (c == '/' && tail[1] == '*') {
-				tail += 2;
-				for (char c; (c = *tail); ++tail) {
-					if (c == '*' && tail[1] == '/') {
-						tail += 2;
-						break;
-					}
-				}
-			} else if (c == '-' && tail[1] == '-') {
-				tail += 2;
-				for (char c; (c = *tail); ++tail) {
-					if (c == '\n') {
-						++tail;
-						break;
-					}
-				}
-			} else {
-				sqlite3_finalize(handle);
-				return ThrowRangeError("The supplied SQL string contains more than one statement");
-			}
-		}
-
-		UseContext;
-		bool returns_data = sqlite3_column_count(handle) >= 1 || pragmaMode;
-		Statement* stmt = new Statement(db, handle, addon->NextId(), returns_data);
-		stmt->Wrap(info.This());
-		SetFrozen(isolate, ctx, info.This(), addon->cs.reader, v8::Boolean::New(isolate, returns_data));
-		SetFrozen(isolate, ctx, info.This(), addon->cs.readonly, v8::Boolean::New(isolate, sqlite3_stmt_readonly(handle) != 0));
-		SetFrozen(isolate, ctx, info.This(), addon->cs.source, source);
-		SetFrozen(isolate, ctx, info.This(), addon->cs.database, database);
-
-		info.GetReturnValue().Set(info.This());
-	}
-
-	NODE_METHOD(JS_run) {
-		STATEMENT_START(ALLOW_ANY_STATEMENT, DOES_MUTATE);
-		sqlite3* db_handle = db->GetHandle();
-		int total_changes_before = sqlite3_total_changes(db_handle);
-
-		sqlite3_step(handle);
-		if (sqlite3_reset(handle) == SQLITE_OK) {
-			int changes = sqlite3_total_changes(db_handle) == total_changes_before ? 0 : sqlite3_changes(db_handle);
-			sqlite3_int64 id = sqlite3_last_insert_rowid(db_handle);
-			Addon* addon = db->GetAddon();
-			UseContext;
-			v8::Local<v8::Object> result = v8::Object::New(isolate);
-			result->Set(ctx, addon->cs.changes.Get(isolate), v8::Int32::New(isolate, changes)).FromJust();
-			result->Set(ctx, addon->cs.lastInsertRowid.Get(isolate),
-				stmt->safe_ints
-					? v8::BigInt::New(isolate, id).As<v8::Value>()
-					: v8::Number::New(isolate, (double)id).As<v8::Value>()
-			).FromJust();
-			STATEMENT_RETURN(result);
-		}
-		STATEMENT_THROW();
-	}
-
-	NODE_METHOD(JS_get) {
-		STATEMENT_START(REQUIRE_STATEMENT_RETURNS_DATA, DOES_NOT_MUTATE);
-		int status = sqlite3_step(handle);
-		if (status == SQLITE_ROW) {
-			v8::Local<v8::Value> result = Data::GetRowJS(isolate, OnlyContext, handle, stmt->safe_ints, stmt->mode);
-			sqlite3_reset(handle);
-			STATEMENT_RETURN(result);
-		} else if (status == SQLITE_DONE) {
-			sqlite3_reset(handle);
-			STATEMENT_RETURN(v8::Undefined(isolate));
-		}
-		sqlite3_reset(handle);
-		STATEMENT_THROW();
-	}
-
-	NODE_METHOD(JS_all) {
-		STATEMENT_START(REQUIRE_STATEMENT_RETURNS_DATA, DOES_NOT_MUTATE);
-		UseContext;
-		v8::Local<v8::Array> result = v8::Array::New(isolate, 0);
-		uint32_t row_count = 0;
-		const bool safe_ints = stmt->safe_ints;
-		const char mode = stmt->mode;
-		bool js_error = false;
-
-		while (sqlite3_step(handle) == SQLITE_ROW) {
-			if (row_count == 0xffffffff) { ThrowRangeError("Array overflow (too many rows returned)"); js_error = true; break; }
-			result->Set(ctx, row_count++, Data::GetRowJS(isolate, ctx, handle, safe_ints, mode)).FromJust();
-		}
-
-		if (sqlite3_reset(handle) == SQLITE_OK && !js_error) {
-			STATEMENT_RETURN(result);
-		}
-		if (js_error) db->GetState()->was_js_error = true;
-		STATEMENT_THROW();
-	}
-
-	NODE_METHOD(JS_iterate) {
-		UseAddon;
-		UseIsolate;
-		v8::Local<v8::Function> c = addon->StatementIterator.Get(isolate);
-		addon->privileged_info = &info;
-		v8::MaybeLocal<v8::Object> maybeIterator = c->NewInstance(OnlyContext, 0, NULL);
-		addon->privileged_info = NULL;
-		if (!maybeIterator.IsEmpty()) info.GetReturnValue().Set(maybeIterator.ToLocalChecked());
-	}
-
-	NODE_METHOD(JS_bind) {
-		Statement* stmt = Unwrap<Statement>(info.This());
-		if (stmt->bound) return ThrowTypeError("The bind() method can only be invoked once per statement object");
-		REQUIRE_DATABASE_OPEN(stmt->db->GetState());
-		REQUIRE_DATABASE_NOT_BUSY(stmt->db->GetState());
-		REQUIRE_STATEMENT_NOT_LOCKED(stmt);
-		STATEMENT_BIND(stmt->handle);
-		stmt->bound = true;
-		info.GetReturnValue().Set(info.This());
-	}
-
-	NODE_METHOD(JS_pluck) {
-		Statement* stmt = Unwrap<Statement>(info.This());
-		if (!stmt->returns_data) return ThrowTypeError("The pluck() method is only for statements that return data");
-		REQUIRE_DATABASE_NOT_BUSY(stmt->db->GetState());
-		REQUIRE_STATEMENT_NOT_LOCKED(stmt);
-		bool use = true;
-		if (info.Length() != 0) { REQUIRE_ARGUMENT_BOOLEAN(first, use); }
-		stmt->mode = use ? Data::PLUCK : stmt->mode == Data::PLUCK ? Data::FLAT : stmt->mode;
-		info.GetReturnValue().Set(info.This());
-	}
-
-	NODE_METHOD(JS_expand) {
-		Statement* stmt = Unwrap<Statement>(info.This());
-		if (!stmt->returns_data) return ThrowTypeError("The expand() method is only for statements that return data");
-		REQUIRE_DATABASE_NOT_BUSY(stmt->db->GetState());
-		REQUIRE_STATEMENT_NOT_LOCKED(stmt);
-		bool use = true;
-		if (info.Length() != 0) { REQUIRE_ARGUMENT_BOOLEAN(first, use); }
-		stmt->mode = use ? Data::EXPAND : stmt->mode == Data::EXPAND ? Data::FLAT : stmt->mode;
-		info.GetReturnValue().Set(info.This());
-	}
-
-	NODE_METHOD(JS_raw) {
-		Statement* stmt = Unwrap<Statement>(info.This());
-		if (!stmt->returns_data) return ThrowTypeError("The raw() method is only for statements that return data");
-		REQUIRE_DATABASE_NOT_BUSY(stmt->db->GetState());
-		REQUIRE_STATEMENT_NOT_LOCKED(stmt);
-		bool use = true;
-		if (info.Length() != 0) { REQUIRE_ARGUMENT_BOOLEAN(first, use); }
-		stmt->mode = use ? Data::RAW : stmt->mode == Data::RAW ? Data::FLAT : stmt->mode;
-		info.GetReturnValue().Set(info.This());
-	}
-
-	NODE_METHOD(JS_safeIntegers) {
-		Statement* stmt = Unwrap<Statement>(info.This());
-		REQUIRE_DATABASE_NOT_BUSY(stmt->db->GetState());
-		REQUIRE_STATEMENT_NOT_LOCKED(stmt);
-		if (info.Length() == 0) stmt->safe_ints = true;
-		else { REQUIRE_ARGUMENT_BOOLEAN(first, stmt->safe_ints); }
-		info.GetReturnValue().Set(info.This());
-	}
-
-	NODE_METHOD(JS_columns) {
-		Statement* stmt = Unwrap<Statement>(info.This());
-		if (!stmt->returns_data) return ThrowTypeError("The columns() method is only for statements that return data");
-		REQUIRE_DATABASE_OPEN(stmt->db->GetState());
-		REQUIRE_DATABASE_NOT_BUSY(stmt->db->GetState());
-		Addon* addon = stmt->db->GetAddon();
-		UseIsolate;
-		UseContext;
-
-		int column_count = sqlite3_column_count(stmt->handle);
-		v8::Local<v8::Array> columns = v8::Array::New(isolate);
-
-		v8::Local<v8::String> name = addon->cs.name.Get(isolate);
-		v8::Local<v8::String> columnName = addon->cs.column.Get(isolate);
-		v8::Local<v8::String> tableName = addon->cs.table.Get(isolate);
-		v8::Local<v8::String> databaseName = addon->cs.database.Get(isolate);
-		v8::Local<v8::String> typeName = addon->cs.type.Get(isolate);
-
-		for (int i = 0; i < column_count; ++i) {
-			v8::Local<v8::Object> column = v8::Object::New(isolate);
-
-			column->Set(ctx, name,
-				InternalizedFromUtf8OrNull(isolate, sqlite3_column_name(stmt->handle, i), -1)
-			).FromJust();
-			column->Set(ctx, columnName,
-				InternalizedFromUtf8OrNull(isolate, sqlite3_column_origin_name(stmt->handle, i), -1)
-			).FromJust();
-			column->Set(ctx, tableName,
-				InternalizedFromUtf8OrNull(isolate, sqlite3_column_table_name(stmt->handle, i), -1)
-			).FromJust();
-			column->Set(ctx, databaseName,
-				InternalizedFromUtf8OrNull(isolate, sqlite3_column_database_name(stmt->handle, i), -1)
-			).FromJust();
-			column->Set(ctx, typeName,
-				InternalizedFromUtf8OrNull(isolate, sqlite3_column_decltype(stmt->handle, i), -1)
-			).FromJust();
-
-			columns->Set(ctx, i, column).FromJust();
-		}
-
-		info.GetReturnValue().Set(columns);
-	}
-
-	NODE_GETTER(JS_busy) {
-		Statement* stmt = Unwrap<Statement>(info.This());
-		info.GetReturnValue().Set(stmt->alive && stmt->locked);
-	}
-
-	Database* const db;
-	sqlite3_stmt* const handle;
-	Extras* const extras;
-	bool alive;
-	bool locked;
-	bool bound;
-	bool has_bind_map;
-	bool safe_ints;
-	char mode;
-	const bool returns_data;
-};

src/util/binder.cpp

@@ -32,25 +32,14 @@ private:
 		bool bound_object;
 	};
 
-#hdr
-	static bool IsPlainObject(v8::Isolate* isolate, v8::Local<v8::Object> obj);
-#end
-#src
 	static bool IsPlainObject(v8::Isolate* isolate, v8::Local<v8::Object> obj) {
 		v8::Local<v8::Value> proto = obj->GetPrototype();
-
-		#if defined NODE_MODULE_VERSION && NODE_MODULE_VERSION < 93
-		v8::Local<v8::Context> ctx = obj->CreationContext();
-		#else
 		v8::Local<v8::Context> ctx = obj->GetCreationContext().ToLocalChecked();
-		#endif
-
 		ctx->Enter();
 		v8::Local<v8::Value> baseProto = v8::Object::New(isolate)->GetPrototype();
 		ctx->Exit();
 		return proto->StrictEquals(baseProto) || proto->StrictEquals(v8::Null(isolate));
 	}
-#end
 
 	void Fail(void (*Throw)(const char* _), const char* message) {
 		assert(success == true);

src/util/custom-aggregate.cpp

@@ -83,7 +83,7 @@ private:
 		v8::Global<v8::Value> value;
 		bool initialized;
 		bool is_window;
-	}
+	};
 
 	Accumulator* GetAccumulator(sqlite3_context* invocation) {
 		Accumulator* acc = static_cast<Accumulator*>(sqlite3_aggregate_context(invocation, sizeof(Accumulator)));

src/util/custom-table.cpp

@@ -17,59 +17,8 @@ public:
 		delete static_cast<CustomTable*>(self);
 	}
 
-	static sqlite3_module MODULE = {
+	static sqlite3_module MODULE;
-		0,                            /* iVersion */
+	static sqlite3_module EPONYMOUS_MODULE;
-		xCreate,                      /* xCreate */
-		xConnect,                     /* xConnect */
-		xBestIndex,                   /* xBestIndex */
-		xDisconnect,                  /* xDisconnect */
-		xDisconnect,                  /* xDestroy */
-		xOpen,                        /* xOpen */
-		xClose,                       /* xClose */
-		xFilter,                      /* xFilter */
-		xNext,                        /* xNext */
-		xEof,                         /* xEof */
-		xColumn,                      /* xColumn */
-		xRowid,                       /* xRowid */
-		NULL,                         /* xUpdate */
-		NULL,                         /* xBegin */
-		NULL,                         /* xSync */
-		NULL,                         /* xCommit */
-		NULL,                         /* xRollback */
-		NULL,                         /* xFindMethod */
-		NULL,                         /* xRename */
-		NULL,                         /* xSavepoint */
-		NULL,                         /* xRelease */
-		NULL,                         /* xRollbackTo */
-		NULL                          /* xShadowName */
-	};
-
-	static sqlite3_module EPONYMOUS_MODULE = {
-		0,                            /* iVersion */
-		NULL,                         /* xCreate */
-		xConnect,                     /* xConnect */
-		xBestIndex,                   /* xBestIndex */
-		xDisconnect,                  /* xDisconnect */
-		xDisconnect,                  /* xDestroy */
-		xOpen,                        /* xOpen */
-		xClose,                       /* xClose */
-		xFilter,                      /* xFilter */
-		xNext,                        /* xNext */
-		xEof,                         /* xEof */
-		xColumn,                      /* xColumn */
-		xRowid,                       /* xRowid */
-		NULL,                         /* xUpdate */
-		NULL,                         /* xBegin */
-		NULL,                         /* xSync */
-		NULL,                         /* xCommit */
-		NULL,                         /* xRollback */
-		NULL,                         /* xFindMethod */
-		NULL,                         /* xRename */
-		NULL,                         /* xSavepoint */
-		NULL,                         /* xRelease */
-		NULL,                         /* xRollbackTo */
-		NULL                          /* xShadowName */
-	};
 
 private:
 
@@ -402,3 +351,59 @@ private:
 	const std::string name;
 	const v8::Global<v8::Function> factory;
 };
+
+sqlite3_module CustomTable::MODULE = {
+	0,                            /* iVersion */
+	xCreate,                      /* xCreate */
+	xConnect,                     /* xConnect */
+	xBestIndex,                   /* xBestIndex */
+	xDisconnect,                  /* xDisconnect */
+	xDisconnect,                  /* xDestroy */
+	xOpen,                        /* xOpen */
+	xClose,                       /* xClose */
+	xFilter,                      /* xFilter */
+	xNext,                        /* xNext */
+	xEof,                         /* xEof */
+	xColumn,                      /* xColumn */
+	xRowid,                       /* xRowid */
+	NULL,                         /* xUpdate */
+	NULL,                         /* xBegin */
+	NULL,                         /* xSync */
+	NULL,                         /* xCommit */
+	NULL,                         /* xRollback */
+	NULL,                         /* xFindMethod */
+	NULL,                         /* xRename */
+	NULL,                         /* xSavepoint */
+	NULL,                         /* xRelease */
+	NULL,                         /* xRollbackTo */
+	NULL,                         /* xShadowName */
+	NULL                          /* xIntegrity */
+};
+
+sqlite3_module CustomTable::EPONYMOUS_MODULE = {
+	0,                            /* iVersion */
+	NULL,                         /* xCreate */
+	xConnect,                     /* xConnect */
+	xBestIndex,                   /* xBestIndex */
+	xDisconnect,                  /* xDisconnect */
+	xDisconnect,                  /* xDestroy */
+	xOpen,                        /* xOpen */
+	xClose,                       /* xClose */
+	xFilter,                      /* xFilter */
+	xNext,                        /* xNext */
+	xEof,                         /* xEof */
+	xColumn,                      /* xColumn */
+	xRowid,                       /* xRowid */
+	NULL,                         /* xUpdate */
+	NULL,                         /* xBegin */
+	NULL,                         /* xSync */
+	NULL,                         /* xCommit */
+	NULL,                         /* xRollback */
+	NULL,                         /* xFindMethod */
+	NULL,                         /* xRename */
+	NULL,                         /* xSavepoint */
+	NULL,                         /* xRelease */
+	NULL,                         /* xRollbackTo */
+	NULL,                         /* xShadowName */
+	NULL                          /* xIntegrity */
+};

src/util/helpers.cpp

@@ -0,0 +1,109 @@
+inline v8::Local<v8::String> StringFromUtf8(v8::Isolate* isolate, const char* data, int length) {
+	return v8::String::NewFromUtf8(isolate, data, v8::NewStringType::kNormal, length).ToLocalChecked();
+}
+
+inline v8::Local<v8::String> InternalizedFromUtf8(v8::Isolate* isolate, const char* data, int length) {
+	return v8::String::NewFromUtf8(isolate, data, v8::NewStringType::kInternalized, length).ToLocalChecked();
+}
+
+inline v8::Local<v8::Value> InternalizedFromUtf8OrNull(v8::Isolate* isolate, const char* data, int length) {
+	if (data == NULL) return v8::Null(isolate);
+	return InternalizedFromUtf8(isolate, data, length);
+}
+
+inline v8::Local<v8::String> InternalizedFromLatin1(v8::Isolate* isolate, const char* str) {
+	return v8::String::NewFromOneByte(isolate, reinterpret_cast<const uint8_t*>(str), v8::NewStringType::kInternalized).ToLocalChecked();
+}
+
+inline void SetFrozen(v8::Isolate* isolate, v8::Local<v8::Context> ctx, v8::Local<v8::Object> obj, v8::Global<v8::String>& key, v8::Local<v8::Value> value) {
+	obj->DefineOwnProperty(ctx, key.Get(isolate), value, static_cast<v8::PropertyAttribute>(v8::DontDelete | v8::ReadOnly)).FromJust();
+}
+
+void ThrowError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::Error(StringFromUtf8(isolate, message, -1))); }
+void ThrowTypeError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::TypeError(StringFromUtf8(isolate, message, -1))); }
+void ThrowRangeError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::RangeError(StringFromUtf8(isolate, message, -1))); }
+
+// Determines whether to skip the given character at the start of an SQL string.
+inline bool IS_SKIPPED(char c) {
+	return c == ' ' || c == ';' || (c >= '\t' && c <= '\r');
+}
+
+// Allocates an empty array, without calling constructors/initializers.
+template<class T> inline T* ALLOC_ARRAY(size_t count) {
+	return static_cast<T*>(::operator new[](count * sizeof(T)));
+}
+
+// Deallocates an array, without calling destructors.
+template<class T> inline void FREE_ARRAY(T* array_pointer) {
+	::operator delete[](array_pointer);
+}
+
+v8::Local<v8::FunctionTemplate> NewConstructorTemplate(
+	v8::Isolate* isolate,
+	v8::Local<v8::External> data,
+	v8::FunctionCallback func,
+	const char* name
+) {
+	v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate, func, data);
+	t->InstanceTemplate()->SetInternalFieldCount(1);
+	t->SetClassName(InternalizedFromLatin1(isolate, name));
+	return t;
+}
+
+void SetPrototypeMethod(
+	v8::Isolate* isolate,
+	v8::Local<v8::External> data,
+	v8::Local<v8::FunctionTemplate> recv,
+	const char* name,
+	v8::FunctionCallback func
+) {
+	v8::HandleScope scope(isolate);
+	recv->PrototypeTemplate()->Set(
+		InternalizedFromLatin1(isolate, name),
+		v8::FunctionTemplate::New(isolate, func, data, v8::Signature::New(isolate, recv))
+	);
+}
+
+void SetPrototypeSymbolMethod(
+	v8::Isolate* isolate,
+	v8::Local<v8::External> data,
+	v8::Local<v8::FunctionTemplate> recv,
+	v8::Local<v8::Symbol> symbol,
+	v8::FunctionCallback func
+) {
+	v8::HandleScope scope(isolate);
+	recv->PrototypeTemplate()->Set(
+		symbol,
+		v8::FunctionTemplate::New(isolate, func, data, v8::Signature::New(isolate, recv))
+	);
+}
+
+void SetPrototypeGetter(
+	v8::Isolate* isolate,
+	v8::Local<v8::External> data,
+	v8::Local<v8::FunctionTemplate> recv,
+	const char* name,
+	v8::AccessorNameGetterCallback func
+) {
+	v8::HandleScope scope(isolate);
+	recv->InstanceTemplate()->SetNativeDataProperty(
+		InternalizedFromLatin1(isolate, name),
+		func,
+		0,
+		data
+	);
+}
+
+#if defined(V8_ENABLE_SANDBOX)
+// When V8 Sandbox is enabled (in newer Electron versions), we need to use Buffer::Copy
+// instead of Buffer::New to ensure the ArrayBuffer backing store is allocated inside the sandbox
+static inline v8::MaybeLocal<v8::Object> BufferSandboxNew(v8::Isolate* isolate, char* data, size_t length, void (*finalizeCallback)(char*, void*), void* finalizeHint) {
+    v8::MaybeLocal<v8::Object> buffer = node::Buffer::Copy(isolate, data, length);
+    finalizeCallback(data, finalizeHint);
+    return buffer;
+}
+#define SAFE_NEW_BUFFER(env, data, length, finalizeCallback, finalizeHint) BufferSandboxNew(env, data, length, finalizeCallback, finalizeHint)
+#else
+// When V8 Sandbox is not enabled, we can use the more efficient Buffer::New
+#define SAFE_NEW_BUFFER(env, data, length, finalizeCallback, finalizeHint) node::Buffer::New(env, data, length, finalizeCallback, finalizeHint)
+#endif

src/util/macros.cpp

@@ -0,0 +1,63 @@
+#define NODE_ARGUMENTS const v8::FunctionCallbackInfo<v8::Value>&
+#define NODE_ARGUMENTS_POINTER const v8::FunctionCallbackInfo<v8::Value>*
+#define NODE_METHOD(name) void name(NODE_ARGUMENTS info)
+#define NODE_GETTER(name) void name(v8::Local<v8::Name> _, const v8::PropertyCallbackInfo<v8::Value>& info)
+#define INIT(name) v8::Local<v8::Function> name(v8::Isolate* isolate, v8::Local<v8::External> data)
+
+#define EasyIsolate v8::Isolate* isolate = v8::Isolate::GetCurrent()
+#define OnlyIsolate info.GetIsolate()
+#define OnlyContext isolate->GetCurrentContext()
+#define OnlyAddon static_cast<Addon*>(info.Data().As<v8::External>()->Value())
+#define UseIsolate v8::Isolate* isolate = OnlyIsolate
+#define UseContext v8::Local<v8::Context> ctx = OnlyContext
+#define UseAddon Addon* addon = OnlyAddon
+#define Unwrap node::ObjectWrap::Unwrap
+
+#define REQUIRE_ARGUMENT_ANY(at, var)                                          \
+	if (info.Length() <= (at()))                                               \
+		return ThrowTypeError("Expected a "#at" argument");                    \
+	var = info[at()]
+
+#define _REQUIRE_ARGUMENT(at, var, Type, message, ...)                         \
+	if (info.Length() <= (at()) || !info[at()]->Is##Type())                    \
+		return ThrowTypeError("Expected "#at" argument to be "#message);       \
+	var = (info[at()].As<v8::Type>())__VA_ARGS__
+
+#define REQUIRE_ARGUMENT_INT32(at, var)                                        \
+	_REQUIRE_ARGUMENT(at, var, Int32, a 32-bit signed integer, ->Value())
+#define REQUIRE_ARGUMENT_BOOLEAN(at, var)                                      \
+	_REQUIRE_ARGUMENT(at, var, Boolean, a boolean, ->Value())
+#define REQUIRE_ARGUMENT_STRING(at, var)                                       \
+	_REQUIRE_ARGUMENT(at, var, String, a string)
+#define REQUIRE_ARGUMENT_OBJECT(at, var)                                       \
+	_REQUIRE_ARGUMENT(at, var, Object, an object)
+#define REQUIRE_ARGUMENT_FUNCTION(at, var)                                     \
+	_REQUIRE_ARGUMENT(at, var, Function, a function)
+
+#define REQUIRE_DATABASE_OPEN(db)                                              \
+	if (!db->open)                                                             \
+		return ThrowTypeError("The database connection is not open")
+#define REQUIRE_DATABASE_NOT_BUSY(db)                                          \
+	if (db->busy)                                                              \
+		return ThrowTypeError("This database connection is busy executing a query")
+#define REQUIRE_DATABASE_NO_ITERATORS(db)                                      \
+	if (db->iterators)                                                         \
+		return ThrowTypeError("This database connection is busy executing a query")
+#define REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db)                        \
+	if (!db->unsafe_mode) {                                                    \
+		REQUIRE_DATABASE_NO_ITERATORS(db);                                     \
+	} ((void)0)
+#define REQUIRE_STATEMENT_NOT_LOCKED(stmt)                                     \
+	if (stmt->locked)                                                          \
+		return ThrowTypeError("This statement is busy executing a query")
+
+#define first() 0
+#define second() 1
+#define third() 2
+#define fourth() 3
+#define fifth() 4
+#define sixth() 5
+#define seventh() 6
+#define eighth() 7
+#define ninth() 8
+#define tenth() 9

src/util/macros.lzz

@@ -1,196 +0,0 @@
-#define NODE_ARGUMENTS const v8::FunctionCallbackInfo<v8::Value>&
-#define NODE_ARGUMENTS_POINTER const v8::FunctionCallbackInfo<v8::Value>*
-#define NODE_METHOD(name) static void name(NODE_ARGUMENTS info)
-#if defined NODE_MODULE_VERSION && NODE_MODULE_VERSION < 121
-#define NODE_GETTER(name) static void name(v8::Local<v8::String> _, const v8::PropertyCallbackInfo<v8::Value>& info)
-#else
-#define NODE_GETTER(name) static void name(v8::Local<v8::Name> _, const v8::PropertyCallbackInfo<v8::Value>& info)
-#endif
-#define INIT(name) static v8::Local<v8::Function> name(v8::Isolate* isolate, v8::Local<v8::External> data)
-
-#define EasyIsolate v8::Isolate* isolate = v8::Isolate::GetCurrent()
-#define OnlyIsolate info.GetIsolate()
-#define OnlyContext isolate->GetCurrentContext()
-#define OnlyAddon static_cast<Addon*>(info.Data().As<v8::External>()->Value())
-#define UseIsolate v8::Isolate* isolate = OnlyIsolate
-#define UseContext v8::Local<v8::Context> ctx = OnlyContext
-#define UseAddon Addon* addon = OnlyAddon
-#define Unwrap node::ObjectWrap::Unwrap
-
-inline v8::Local<v8::String> StringFromUtf8(v8::Isolate* isolate, const char* data, int length) {
-    return v8::String::NewFromUtf8(isolate, data, v8::NewStringType::kNormal, length).ToLocalChecked();
-}
-inline v8::Local<v8::String> InternalizedFromUtf8(v8::Isolate* isolate, const char* data, int length) {
-    return v8::String::NewFromUtf8(isolate, data, v8::NewStringType::kInternalized, length).ToLocalChecked();
-}
-inline v8::Local<v8::Value> InternalizedFromUtf8OrNull(v8::Isolate* isolate, const char* data, int length) {
-    if (data == NULL) return v8::Null(isolate);
-    return InternalizedFromUtf8(isolate, data, length);
-}
-inline v8::Local<v8::String> InternalizedFromLatin1(v8::Isolate* isolate, const char* str) {
-    return v8::String::NewFromOneByte(isolate, reinterpret_cast<const uint8_t*>(str), v8::NewStringType::kInternalized).ToLocalChecked();
-}
-
-inline void SetFrozen(v8::Isolate* isolate, v8::Local<v8::Context> ctx, v8::Local<v8::Object> obj, v8::Global<v8::String>& key, v8::Local<v8::Value> value) {
-    obj->DefineOwnProperty(ctx, key.Get(isolate), value, static_cast<v8::PropertyAttribute>(v8::DontDelete | v8::ReadOnly)).FromJust();
-}
-
-void ThrowError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::Error(StringFromUtf8(isolate, message, -1))); }
-void ThrowTypeError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::TypeError(StringFromUtf8(isolate, message, -1))); }
-void ThrowRangeError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::RangeError(StringFromUtf8(isolate, message, -1))); }
-
-#define REQUIRE_ARGUMENT_ANY(at, var)                                          \
-	if (info.Length() <= (at()))                                               \
-		return ThrowTypeError("Expected a "#at" argument");                    \
-	var = info[at()]
-
-#define _REQUIRE_ARGUMENT(at, var, Type, message, ...)                         \
-	if (info.Length() <= (at()) || !info[at()]->Is##Type())                    \
-		return ThrowTypeError("Expected "#at" argument to be "#message);       \
-	var = (info[at()].As<v8::Type>())__VA_ARGS__
-
-#define REQUIRE_ARGUMENT_INT32(at, var)                                        \
-	_REQUIRE_ARGUMENT(at, var, Int32, a 32-bit signed integer, ->Value())
-#define REQUIRE_ARGUMENT_BOOLEAN(at, var)                                      \
-	_REQUIRE_ARGUMENT(at, var, Boolean, a boolean, ->Value())
-#define REQUIRE_ARGUMENT_STRING(at, var)                                       \
-	_REQUIRE_ARGUMENT(at, var, String, a string)
-#define REQUIRE_ARGUMENT_OBJECT(at, var)                                       \
-	_REQUIRE_ARGUMENT(at, var, Object, an object)
-#define REQUIRE_ARGUMENT_FUNCTION(at, var)                                     \
-	_REQUIRE_ARGUMENT(at, var, Function, a function)
-
-#define REQUIRE_DATABASE_OPEN(db)                                              \
-	if (!db->open)                                                             \
-		return ThrowTypeError("The database connection is not open")
-#define REQUIRE_DATABASE_NOT_BUSY(db)                                          \
-	if (db->busy)                                                              \
-		return ThrowTypeError("This database connection is busy executing a query")
-#define REQUIRE_DATABASE_NO_ITERATORS(db)                                      \
-	if (db->iterators)                                                         \
-		return ThrowTypeError("This database connection is busy executing a query")
-#define REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db)                        \
-	if (!db->unsafe_mode) {                                                    \
-		REQUIRE_DATABASE_NO_ITERATORS(db);                                     \
-	} ((void)0)
-#define REQUIRE_STATEMENT_NOT_LOCKED(stmt)                                     \
-	if (stmt->locked)                                                          \
-		return ThrowTypeError("This statement is busy executing a query")
-
-#define first() 0
-#define second() 1
-#define third() 2
-#define fourth() 3
-#define fifth() 4
-#define sixth() 5
-#define seventh() 6
-#define eighth() 7
-#define ninth() 8
-#define tenth() 9
-
-// Determines whether to skip the given character at the start of an SQL string.
-inline bool IS_SKIPPED(char c) {
-    return c == ' ' || c == ';' || (c >= '\t' && c <= '\r');
-}
-
-// Allocates an empty array, without calling constructors/initializers.
-template<class T> inline T* ALLOC_ARRAY(size_t count) {
-    return static_cast<T*>(::operator new[](count * sizeof(T)));
-}
-
-// Deallocates an array, without calling destructors.
-template<class T> inline void FREE_ARRAY(T* array_pointer) {
-    ::operator delete[](array_pointer);
-}
-
-v8::Local<v8::FunctionTemplate> NewConstructorTemplate(
-        v8::Isolate* isolate,
-        v8::Local<v8::External> data,
-        v8::FunctionCallback func,
-        const char* name
-) {
-    v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate, func, data);
-    t->InstanceTemplate()->SetInternalFieldCount(1);
-    t->SetClassName(InternalizedFromLatin1(isolate, name));
-    return t;
-}
-void SetPrototypeMethod(
-        v8::Isolate* isolate,
-        v8::Local<v8::External> data,
-        v8::Local<v8::FunctionTemplate> recv,
-        const char* name,
-        v8::FunctionCallback func
-) {
-    v8::HandleScope scope(isolate);
-    recv->PrototypeTemplate()->Set(
-            InternalizedFromLatin1(isolate, name),
-            v8::FunctionTemplate::New(isolate, func, data, v8::Signature::New(isolate, recv))
-    );
-}
-void SetPrototypeSymbolMethod(
-        v8::Isolate* isolate,
-        v8::Local<v8::External> data,
-        v8::Local<v8::FunctionTemplate> recv,
-        v8::Local<v8::Symbol> symbol,
-        v8::FunctionCallback func
-) {
-    v8::HandleScope scope(isolate);
-    recv->PrototypeTemplate()->Set(
-            symbol,
-            v8::FunctionTemplate::New(isolate, func, data, v8::Signature::New(isolate, recv))
-    );
-}
-
-#hdr
-void SetPrototypeGetter(
-        v8::Isolate* isolate,
-        v8::Local<v8::External> data,
-        v8::Local<v8::FunctionTemplate> recv,
-        const char* name,
-        v8::AccessorNameGetterCallback func
-);
-#end
-#src
-void SetPrototypeGetter(
-        v8::Isolate* isolate,
-        v8::Local<v8::External> data,
-        v8::Local<v8::FunctionTemplate> recv,
-        const char* name,
-        v8::AccessorNameGetterCallback func
-) {
-    v8::HandleScope scope(isolate);
-
-#if defined NODE_MODULE_VERSION && NODE_MODULE_VERSION < 121
-    recv->InstanceTemplate()->SetAccessor(
-		InternalizedFromLatin1(isolate, name),
-		func,
-		0,
-		data,
-		v8::AccessControl::DEFAULT,
-		v8::PropertyAttribute::None
-	);
-#else
-    recv->InstanceTemplate()->SetNativeDataProperty(
-            InternalizedFromLatin1(isolate, name),
-            func,
-            0,
-            data
-    );
-#endif
-}
-#end
-#src
-#if defined(V8_ENABLE_SANDBOX)
-// When V8 Sandbox is enabled (in newer Electron versions), we need to use Buffer::Copy
-// instead of Buffer::New to ensure the ArrayBuffer backing store is allocated inside the sandbox
-static inline v8::MaybeLocal<v8::Object> BufferSandboxNew(v8::Isolate* isolate, char* data, size_t length, void (*finalizeCallback)(char*, void*), void* finalizeHint) {
-    v8::MaybeLocal<v8::Object> buffer = node::Buffer::Copy(isolate, data, length);
-    finalizeCallback(data, finalizeHint);
-    return buffer;
-}
-#define SAFE_NEW_BUFFER(env, data, length, finalizeCallback, finalizeHint) BufferSandboxNew(env, data, length, finalizeCallback, finalizeHint)
-#else
-// When V8 Sandbox is not enabled, we can use the more efficient Buffer::New
-#define SAFE_NEW_BUFFER(env, data, length, finalizeCallback, finalizeHint) node::Buffer::New(env, data, length, finalizeCallback, finalizeHint)
-#endif
-#end