@barakxyz/better-sqlite3 12.6.2

package/src/objects/session.cpp

@@ -0,0 +1,148 @@
+Session::Session(
+	Database* db,
+	sqlite3_session* session_handle,
+	sqlite3_uint64 id
+) :
+	node::ObjectWrap(),
+	db(db),
+	session_handle(session_handle),
+	id(id),
+	alive(true) {
+	assert(db != NULL);
+	assert(session_handle != NULL);
+	db->AddSession(this);
+}
+
+Session::~Session() {
+	if (alive) db->RemoveSession(this);
+	CloseHandles();
+}
+
+// Whenever this is used, db->RemoveSession must be invoked beforehand.
+void Session::CloseHandles() {
+	if (alive) {
+		alive = false;
+		sqlite3session_delete(session_handle);
+	}
+}
+
+INIT(Session::Init) {
+	v8::Local<v8::FunctionTemplate> t = NewConstructorTemplate(isolate, data, JS_new, "Session");
+	SetPrototypeMethod(isolate, data, t, "attach", JS_attach);
+	SetPrototypeMethod(isolate, data, t, "changeset", JS_changeset);
+	SetPrototypeMethod(isolate, data, t, "close", JS_close);
+	return t->GetFunction(OnlyContext).ToLocalChecked();
+}
+
+NODE_METHOD(Session::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> dbName = (*addon->privileged_info)[1].As<v8::String>();
+
+	UseIsolate;
+	v8::String::Utf8Value db_name(isolate, dbName);
+
+	sqlite3_session* session_handle;
+	int status = sqlite3session_create(db->GetHandle(), *db_name, &session_handle);
+
+	if (status != SQLITE_OK) {
+		Database::ThrowSqliteError(addon, db->GetHandle());
+		return;
+	}
+
+	Session* session = new Session(db, session_handle, addon->NextId());
+	session->Wrap(info.This());
+	SetFrozen(isolate, OnlyContext, info.This(), addon->cs.database, database);
+
+	info.GetReturnValue().Set(info.This());
+}
+
+NODE_METHOD(Session::JS_attach) {
+	Session* session = Unwrap<Session>(info.This());
+	if (!session->alive) return ThrowTypeError("The session has been closed");
+	REQUIRE_DATABASE_OPEN(session->db->GetState());
+
+	UseIsolate;
+	const char* table_name = NULL;
+
+	// If a string argument is provided, attach only that table
+	// If null/undefined or no argument, attach all tables (NULL)
+	if (info.Length() > 0 && !info[0]->IsNullOrUndefined()) {
+		if (!info[0]->IsString()) {
+			return ThrowTypeError("Expected first argument to be a string or null");
+		}
+		v8::String::Utf8Value utf8(isolate, info[0].As<v8::String>());
+		table_name = *utf8;
+		int status = sqlite3session_attach(session->session_handle, table_name);
+		if (status != SQLITE_OK) {
+			session->db->ThrowDatabaseError();
+		}
+	} else {
+		// NULL means attach all tables
+		int status = sqlite3session_attach(session->session_handle, NULL);
+		if (status != SQLITE_OK) {
+			session->db->ThrowDatabaseError();
+		}
+	}
+}
+
+// Custom destructor for sqlite3_free
+static void FreeSqliteMemory(char* data, void* hint) {
+	sqlite3_free(data);
+}
+
+NODE_METHOD(Session::JS_changeset) {
+	Session* session = Unwrap<Session>(info.This());
+	if (!session->alive) return ThrowTypeError("The session has been closed");
+	REQUIRE_DATABASE_OPEN(session->db->GetState());
+
+	int size = 0;
+	void* buffer = NULL;
+	int status = sqlite3session_changeset(session->session_handle, &size, &buffer);
+
+	if (status != SQLITE_OK) {
+		session->db->ThrowDatabaseError();
+		return;
+	}
+
+	UseIsolate;
+
+	// If no changes, return undefined
+	if (buffer == NULL || size == 0) {
+		if (buffer) sqlite3_free(buffer);
+		info.GetReturnValue().Set(v8::Undefined(isolate));
+		return;
+	}
+
+	// Create a Node.js Buffer from the changeset data
+	// sqlite3_free will be called when the buffer is garbage collected
+	auto result = SAFE_NEW_BUFFER(
+		isolate,
+		reinterpret_cast<char*>(buffer),
+		size,
+		FreeSqliteMemory,
+		NULL
+	);
+
+	if (result.IsEmpty()) {
+		sqlite3_free(buffer);
+		return ThrowError("Failed to create buffer for changeset");
+	}
+
+	info.GetReturnValue().Set(result.ToLocalChecked());
+}
+
+NODE_METHOD(Session::JS_close) {
+	Session* session = Unwrap<Session>(info.This());
+	if (session->alive) {
+		session->db->RemoveSession(session);
+		session->CloseHandles();
+	}
+	info.GetReturnValue().Set(info.This());
+}

package/src/objects/session.hpp

@@ -0,0 +1,33 @@
+class Session : public node::ObjectWrap {
+public:
+
+	~Session();
+
+	// Whenever this is used, db->RemoveSession must be invoked beforehand.
+	void CloseHandles();
+
+	// Used to support ordered containers.
+	static inline bool Compare(Session const * const a, Session const * const b) {
+		return a->id < b->id;
+	}
+
+	static INIT(Init);
+
+private:
+
+	explicit Session(
+		Database* db,
+		sqlite3_session* session_handle,
+		sqlite3_uint64 id
+	);
+
+	static NODE_METHOD(JS_new);
+	static NODE_METHOD(JS_attach);
+	static NODE_METHOD(JS_changeset);
+	static NODE_METHOD(JS_close);
+
+	Database* const db;
+	sqlite3_session* session_handle;
+	const sqlite3_uint64 id;
+	bool alive;
+};

package/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());
+}

package/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;
+};