pi-para 0.7.8 → 0.7.9

package/node_modules/better-sqlite3/src/objects/statement-iterator.cpp

@@ -0,0 +1,119 @@
+const napi_type_tag StatementIterator::TYPE_TAG = RandomTypeTag();
+
+StatementIterator::StatementIterator(const Napi::CallbackInfo& info) :
+	Napi::ObjectWrap<StatementIterator>(info),
+	stmt(NULL),
+	handle(NULL),
+	db_state(NULL),
+	bound(false),
+	safe_ints(false),
+	mode(Data::FLAT),
+	alive(false),
+	logged(false) {
+	TYPE_TAG_CONSTRUCTOR(info);
+	JS_new(info);
+}
+
+// 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() {}
+
+Napi::Value StatementIterator::Next(Napi::Env env) {
+	assert(alive == true);
+	db_state->busy = true;
+	if (!logged) {
+		logged = true;
+		if (stmt->db->Log(env, handle)) {
+			db_state->busy = false;
+			return Throw(env);
+		}
+	}
+	int status = sqlite3_step(handle);
+	db_state->busy = false;
+
+	if (status == SQLITE_ROW) {
+		Napi::Value row = Data::GetRowJS(env, stmt, handle, safe_ints, mode);
+		return NewRecord(env, row, db_state->addon, false);
+	} else {
+		if (status == SQLITE_DONE) return Return(env);
+		return Throw(env);
+	}
+}
+
+Napi::Value StatementIterator::Return(Napi::Env env) {
+	Cleanup();
+	STATEMENT_RETURN_LOGIC(DoneRecord(env, db_state->addon));
+}
+
+Napi::Value StatementIterator::Throw(Napi::Env env) {
+	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) {
+	return DefineClass(env, "StatementIterator", {
+		PrototypeMethod<StatementIterator, &StatementIterator::JS_next>("next", addon),
+		PrototypeMethod<StatementIterator, &StatementIterator::JS_return>("return", addon),
+		PrototypeSymbolMethod<StatementIterator, &StatementIterator::JS_symbolIterator>(Napi::Symbol::WellKnown(env, "iterator"), addon),
+	}, addon);
+}
+
+NODE_METHOD(StatementIterator::JS_new) {
+	UseAddon;
+	if (!addon->privileged_info) return ThrowTypeError(info.Env(), "Disabled constructor");
+	assert(info.IsConstructCall());
+
+	{
+		const Napi::CallbackInfo& info = *addon->privileged_info;
+		STATEMENT_START_LOGIC(REQUIRE_STATEMENT_RETURNS_DATA, DOES_ADD_ITERATOR);
+		this->stmt = stmt;
+		this->handle = stmt->handle;
+		this->db_state = stmt->db->GetState();
+		this->bound = bound;
+		this->safe_ints = stmt->safe_ints;
+		this->mode = stmt->mode;
+		this->alive = true;
+		this->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;
+	}
+
+	UseIsolate;
+	SetFrozen(env, info.This().As<Napi::Object>(), addon->cs.statement, addon->privileged_info->This());
+
+	return info.This();
+}
+
+NODE_METHOD(StatementIterator::JS_next) {
+	UNWRAP_OR_RETURN(StatementIterator, iter, info.This());
+	REQUIRE_DATABASE_NOT_BUSY(iter->db_state);
+	if (iter->alive) return iter->Next(info.Env());
+	return DoneRecord(info.Env(), iter->db_state->addon);
+}
+
+NODE_METHOD(StatementIterator::JS_return) {
+	UNWRAP_OR_RETURN(StatementIterator, iter, info.This());
+	REQUIRE_DATABASE_NOT_BUSY(iter->db_state);
+	if (iter->alive) return iter->Return(info.Env());
+	return DoneRecord(info.Env(), iter->db_state->addon);
+}
+
+NODE_METHOD(StatementIterator::JS_symbolIterator) {
+	return info.This();
+}

package/node_modules/better-sqlite3/src/objects/statement-iterator.hpp

@@ -0,0 +1,71 @@
+class StatementIterator : public Napi::ObjectWrap<StatementIterator> {
+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.
+	explicit StatementIterator(const Napi::CallbackInfo& info);
+	~StatementIterator();
+
+	// Identifies objects that are backed by this class (see IsInstanceOf).
+	static const napi_type_tag TYPE_TAG;
+
+	static INIT(Init);
+
+private:
+
+	Napi::Value Next(Napi::Env env);
+	Napi::Value Return(Napi::Env env);
+	Napi::Value Throw(Napi::Env env);
+	void Cleanup();
+
+	static inline Napi::Object NewRecord(
+		Napi::Env env,
+		Napi::Value value,
+		Addon* addon,
+		bool done
+	) {
+		assert(!addon->RecordFactory.IsEmpty());
+
+		// Fast path, using a factory function from JS land.
+		if (!done) {
+			napi_value arg = value;
+			return SafeCall(env, addon->RecordFactory.Value(), env.Undefined(), 1, &arg)
+				.As<Napi::Object>();
+		}
+
+		// Slow path, only used after the iterator is done.
+		napi_property_descriptor properties[2] = {};
+		properties[0].name = addon->cs.value.Value();
+		properties[0].value = value;
+		properties[0].attributes = DEFAULT_ATTRIBUTES;
+		properties[1].name = addon->cs.done.Value();
+		properties[1].value = Napi::Boolean::New(env, done);
+		properties[1].attributes = DEFAULT_ATTRIBUTES;
+
+		napi_value record;
+		napi_status status = napi_create_object(env, &record);
+		assert(status == napi_ok || status == napi_cannot_run_js);
+		status = napi_define_properties(env, record, 2, properties);
+		assert(status == napi_ok || status == napi_cannot_run_js); ((void)status);
+		return Napi::Object(env, record);
+	}
+
+	static inline Napi::Object DoneRecord(Napi::Env env, Addon* addon) {
+		return NewRecord(env, env.Undefined(), addon, true);
+	}
+
+	NODE_METHOD(JS_new);
+	static NODE_METHOD(JS_next);
+	static NODE_METHOD(JS_return);
+	static NODE_METHOD(JS_symbolIterator);
+
+	Statement* stmt;
+	sqlite3_stmt* handle;
+	Database::State* db_state;
+	bool bound;
+	bool safe_ints;
+	char mode;
+	bool alive;
+	bool logged;
+};

package/node_modules/better-sqlite3/src/objects/statement.cpp

@@ -0,0 +1,380 @@
+const napi_type_tag Statement::TYPE_TAG = RandomTypeTag();
+
+Statement::Statement(const Napi::CallbackInfo& info) :
+	Napi::ObjectWrap<Statement>(info),
+	db(NULL),
+	handle(NULL),
+	extras(NULL),
+	alive(false),
+	locked(false),
+	bound(false),
+	has_bind_map(false),
+	safe_ints(false),
+	mode(Data::FLAT),
+	returns_data(false) {
+	TYPE_TAG_CONSTRUCTOR(info);
+	JS_new(info);
+}
+
+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(Napi::Env env) {
+	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(env, name + 1, i);
+	}
+	has_bind_map = true;
+	return bind_map;
+}
+
+// Returns the Statement's row builder.
+RowBuilder& Statement::GetRowBuilder() {
+	return extras->row_builder;
+}
+
+Statement::Extras::Extras(
+	Napi::Env env,
+	Napi::Function row_factory,
+	Napi::Function array_factory,
+	sqlite3_uint64 id
+) :
+	bind_map(0),
+	row_builder(env, row_factory, array_factory),
+	id(id) {}
+
+INIT(Statement::Init) {
+	return DefineClass(env, "Statement", {
+		PrototypeMethod<Statement, &Statement::JS_run>("run", addon),
+		PrototypeMethod<Statement, &Statement::JS_get>("get", addon),
+		PrototypeMethod<Statement, &Statement::JS_all>("all", addon),
+		PrototypeMethod<Statement, &Statement::JS_iterate>("iterate", addon),
+		PrototypeMethod<Statement, &Statement::JS_bind>("bind", addon),
+		PrototypeMethod<Statement, &Statement::JS_pluck>("pluck", addon),
+		PrototypeMethod<Statement, &Statement::JS_expand>("expand", addon),
+		PrototypeMethod<Statement, &Statement::JS_raw>("raw", addon),
+		PrototypeMethod<Statement, &Statement::JS_safeIntegers>("safeIntegers", addon),
+		PrototypeMethod<Statement, &Statement::JS_columns>("columns", addon),
+		PrototypeMethod<Statement, &Statement::JS_toString>("toString", addon),
+	}, addon);
+}
+
+NODE_METHOD(Statement::JS_new) {
+	UseAddon;
+	if (!addon->privileged_info) {
+		return ThrowTypeError(info.Env(), "Statements can only be constructed by the db.prepare() method");
+	}
+	assert(info.IsConstructCall());
+	const Napi::CallbackInfo& pinfo = *addon->privileged_info;
+	UNWRAP_OR_RETURN(Database, db, pinfo.This());
+	REQUIRE_DATABASE_OPEN(db->GetState());
+	REQUIRE_DATABASE_NOT_BUSY(db->GetState());
+
+	Napi::String source = pinfo[0].As<Napi::String>();
+	Napi::Object database = pinfo[1].As<Napi::Object>();
+	bool pragmaMode = pinfo[2].As<Napi::Boolean>().Value();
+	bool explainMode = pinfo[3].As<Napi::Boolean>().Value();
+	int flags = SQLITE_PREPARE_PERSISTENT;
+
+	if (pragmaMode) {
+		REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db->GetState());
+		flags = 0;
+	}
+	if (explainMode) {
+		flags = 0;
+	}
+
+	UseIsolate;
+	std::string utf8 = source.Utf8Value();
+	sqlite3_stmt* handle;
+	const char* tail;
+
+	if (sqlite3_prepare_v3(db->GetHandle(), utf8.c_str(), utf8.length() + 1, flags, &handle, &tail) != SQLITE_OK) {
+		db->ThrowDatabaseError(env);
+		return env.Undefined();
+	}
+	if (handle == NULL) {
+		return ThrowRangeError(env, "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(env, "The supplied SQL string contains more than one statement");
+		}
+	}
+
+	bool returns_data = sqlite3_column_count(handle) >= 1 || pragmaMode;
+	this->db = db;
+	this->handle = handle;
+	this->extras = new Extras(env, addon->RowFactory.Value(), addon->ArrayFactory.Value(), addon->NextId());
+	this->bound = explainMode;
+	this->safe_ints = db->GetState()->safe_ints;
+	this->returns_data = returns_data;
+	this->alive = true;
+	assert(db->GetState()->open);
+	assert(!db->GetState()->busy);
+	db->AddStatement(this);
+
+	Napi::Object _this = info.This().As<Napi::Object>();
+	SetFrozen(env, _this, addon->cs.reader, Napi::Boolean::New(env, returns_data));
+	SetFrozen(env, _this, addon->cs.readonly, Napi::Boolean::New(env, sqlite3_stmt_readonly(handle) != 0));
+	SetFrozen(env, _this, addon->cs.source, source);
+	SetFrozen(env, _this, addon->cs.database, database);
+	SetInstanceGetter<Statement, &Statement::JS_busy>(_this, "busy", addon);
+
+	return 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();
+
+		napi_property_descriptor properties[2] = {};
+		properties[0].name = addon->cs.changes.Value();
+		properties[0].value = Napi::Number::New(env, changes);
+		properties[0].attributes = DEFAULT_ATTRIBUTES;
+		properties[1].name = addon->cs.lastInsertRowid.Value();
+		if (stmt->safe_ints) {
+			properties[1].value = Napi::BigInt::New(env, (int64_t)id);
+		} else {
+			properties[1].value = Napi::Number::New(env, (double)id);
+		}
+		properties[1].attributes = DEFAULT_ATTRIBUTES;
+
+		napi_value result;
+		napi_status status = napi_create_object(env, &result);
+		assert(status == napi_ok || status == napi_cannot_run_js);
+		status = napi_define_properties(env, result, 2, properties);
+		assert(status == napi_ok || status == napi_cannot_run_js); ((void)status);
+		STATEMENT_RETURN(Napi::Object(env, 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) {
+		Napi::Value result = Data::GetRowJS(env, stmt, handle, stmt->safe_ints, stmt->mode);
+		sqlite3_reset(handle);
+		STATEMENT_RETURN(result);
+	} else if (status == SQLITE_DONE) {
+		sqlite3_reset(handle);
+		STATEMENT_RETURN(env.Undefined());
+	}
+	sqlite3_reset(handle);
+	STATEMENT_THROW();
+}
+
+NODE_METHOD(Statement::JS_all) {
+	STATEMENT_START(REQUIRE_STATEMENT_RETURNS_DATA, DOES_NOT_MUTATE);
+	const bool safe_ints = stmt->safe_ints;
+	const char mode = stmt->mode;
+
+	std::vector<napi_value> rows;
+	rows.reserve(8);
+
+	while (sqlite3_step(handle) == SQLITE_ROW) {
+		rows.emplace_back(Data::GetRowJS(env, stmt, handle, safe_ints, mode));
+	}
+
+	if (sqlite3_reset(handle) == SQLITE_OK) {
+		if (rows.size() > 0xffffffff) {
+			ThrowRangeError(env, "Array overflow (too many rows returned)");
+			db->GetState()->was_js_error = true;
+		} else {
+			Addon* addon = db->GetAddon();
+			assert(!addon->ArrayFactory.IsEmpty());
+			assert(!addon->ArrayAppender.IsEmpty());
+			static const size_t batch_size = 1024;
+			size_t first_batch_size = std::min(rows.size(), batch_size);
+			Napi::Value result = SafeCall(env, addon->ArrayFactory.Value(), env.Undefined(), first_batch_size, rows.data());
+			if (!env.IsExceptionPending()) {
+				napi_value args[batch_size + 1];
+				args[0] = result;
+				for (size_t offset = first_batch_size; offset < rows.size(); offset += batch_size) {
+					size_t count = std::min(rows.size() - offset, batch_size);
+					std::copy_n(rows.data() + offset, count, args + 1);
+					SafeCall(env, addon->ArrayAppender.Value(), env.Undefined(), count + 1, args);
+					if (env.IsExceptionPending()) break;
+				}
+			}
+			if (env.IsExceptionPending()) {
+				db->GetState()->was_js_error = true;
+			} else {
+				STATEMENT_RETURN(result);
+			}
+		}
+	}
+	STATEMENT_THROW();
+}
+
+NODE_METHOD(Statement::JS_iterate) {
+	UseAddon;
+	UseIsolate;
+	Napi::Function c = addon->StatementIterator.Value();
+	addon->privileged_info = &info;
+	Napi::Object iterator = SafeConstruct(env, c);
+	addon->privileged_info = NULL;
+	if (env.IsExceptionPending()) return env.Undefined();
+	return iterator;
+}
+
+NODE_METHOD(Statement::JS_bind) {
+	UNWRAP_OR_RETURN(Statement, stmt, info.This());
+	if (stmt->bound) return ThrowTypeError(info.Env(), "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;
+	return info.This();
+}
+
+NODE_METHOD(Statement::JS_pluck) {
+	UNWRAP_OR_RETURN(Statement, stmt, info.This());
+	if (!stmt->returns_data) return ThrowTypeError(info.Env(), "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;
+	return info.This();
+}
+
+NODE_METHOD(Statement::JS_expand) {
+	UNWRAP_OR_RETURN(Statement, stmt, info.This());
+	if (!stmt->returns_data) return ThrowTypeError(info.Env(), "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;
+	return info.This();
+}
+
+NODE_METHOD(Statement::JS_raw) {
+	UNWRAP_OR_RETURN(Statement, stmt, info.This());
+	if (!stmt->returns_data) return ThrowTypeError(info.Env(), "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;
+	return info.This();
+}
+
+NODE_METHOD(Statement::JS_safeIntegers) {
+	UNWRAP_OR_RETURN(Statement, stmt, 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); }
+	return info.This();
+}
+
+NODE_METHOD(Statement::JS_columns) {
+	UNWRAP_OR_RETURN(Statement, stmt, info.This());
+	if (!stmt->returns_data) return ThrowTypeError(info.Env(), "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;
+
+	int column_count = sqlite3_column_count(stmt->handle);
+	Napi::Array columns = Napi::Array::New(env, column_count);
+
+	Napi::String name = addon->cs.name.Value();
+	Napi::String columnName = addon->cs.column.Value();
+	Napi::String tableName = addon->cs.table.Value();
+	Napi::String databaseName = addon->cs.database.Value();
+	Napi::String typeName = addon->cs.type.Value();
+
+	for (int i = 0; i < column_count; ++i) {
+		Napi::Object column = Napi::Object::New(env);
+
+		column.Set(name,
+			InternalizedFromUtf8OrNull(env, sqlite3_column_name(stmt->handle, i), -1)
+		);
+		column.Set(columnName,
+			InternalizedFromUtf8OrNull(env, sqlite3_column_origin_name(stmt->handle, i), -1)
+		);
+		column.Set(tableName,
+			InternalizedFromUtf8OrNull(env, sqlite3_column_table_name(stmt->handle, i), -1)
+		);
+		column.Set(databaseName,
+			InternalizedFromUtf8OrNull(env, sqlite3_column_database_name(stmt->handle, i), -1)
+		);
+		column.Set(typeName,
+			InternalizedFromUtf8OrNull(env, sqlite3_column_decltype(stmt->handle, i), -1)
+		);
+
+		columns.Set(i, column);
+	}
+
+	return columns;
+}
+
+NODE_METHOD(Statement::JS_toString) {
+	UNWRAP_OR_RETURN(Statement, stmt, info.This());
+	Addon* addon = stmt->db->GetAddon();
+
+	char* expanded = stmt->alive && stmt->bound ? sqlite3_expanded_sql(stmt->handle) : NULL;
+	if (expanded != NULL) {
+		Napi::Value ret = StringFromUtf8(info.Env(), expanded, -1);
+		sqlite3_free(expanded);
+		return ret;
+	}
+
+	return info.This().As<Napi::Object>()
+		.Get(addon->cs.source.Value())
+		.As<Napi::String>();
+}
+
+NODE_GETTER(Statement::JS_busy) {
+	UNWRAP_OR_RETURN(Statement, stmt, info.This());
+	return Napi::Boolean::New(info.Env(), stmt->alive && stmt->locked);
+}

package/node_modules/better-sqlite3/src/objects/statement.hpp

@@ -0,0 +1,65 @@
+class Statement : public Napi::ObjectWrap<Statement> { friend class StatementIterator;
+public:
+
+	explicit Statement(const Napi::CallbackInfo& info);
+	~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(Napi::Env env);
+
+	// Returns the Statement's row builder.
+	RowBuilder& GetRowBuilder();
+
+	// Identifies objects that are backed by this class (see IsInstanceOf).
+	static const napi_type_tag TYPE_TAG;
+
+	static INIT(Init);
+
+private:
+
+	// A class for holding values that are less often used.
+	class Extras { friend class Statement; friend class StatementIterator;
+		explicit Extras(
+			Napi::Env env,
+			Napi::Function row_factory,
+			Napi::Function array_Factory,
+			sqlite3_uint64 id
+		);
+		BindMap bind_map;
+		RowBuilder row_builder;
+		const sqlite3_uint64 id;
+	};
+
+	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_METHOD(JS_toString);
+	static NODE_GETTER(JS_busy);
+
+	Database* db;
+	sqlite3_stmt* handle;
+	Extras* extras;
+	bool alive;
+	bool locked;
+	bool bound;
+	bool has_bind_map;
+	bool safe_ints;
+	char mode;
+	bool returns_data;
+};

package/node_modules/better-sqlite3/src/util/bind-map.cpp

@@ -0,0 +1,73 @@
+class BindMap {
+public:
+
+	// This nested class represents a single mapping between a parameter name
+	// and its associated parameter index in a prepared statement.
+	class Pair { friend class BindMap;
+		public:
+
+			inline int GetIndex() {
+				return index;
+			}
+
+			inline Napi::String GetName(Napi::Env env) {
+				return name.Value();
+			}
+
+		private:
+
+			explicit Pair(Napi::Env env, const char* name, int index)
+				: name(Napi::Persistent(InternalizedFromUtf8(env, name, -1))), index(index) {}
+
+			explicit Pair(Napi::Env env, Pair* pair)
+				: name(Napi::Persistent(pair->name.Value())), index(pair->index) {}
+
+			const Napi::Reference<Napi::String> name;
+			const int index;
+	};
+
+	explicit BindMap(char _) {
+		assert(_ == 0);
+		pairs = NULL;
+		capacity = 0;
+		length = 0;
+	}
+
+	~BindMap() {
+		while (length) pairs[--length].~Pair();
+		FREE_ARRAY<Pair>(pairs);
+	}
+
+	inline Pair* GetPairs() {
+		return pairs;
+	}
+
+	inline int GetSize() {
+		return length;
+	}
+
+	// Adds a pair to the bind map, expanding the capacity if necessary.
+	void Add(Napi::Env env, const char* name, int index) {
+		assert(name != NULL);
+		if (capacity == length) Grow(env);
+		new (pairs + length++) Pair(env, name, index);
+	}
+
+private:
+
+	void Grow(Napi::Env env) {
+		assert(capacity == length);
+		capacity = (capacity << 1) | 2;
+		Pair* new_pairs = ALLOC_ARRAY<Pair>(capacity);
+		for (int i = 0; i < length; ++i) {
+			new (new_pairs + i) Pair(env, pairs + i);
+			pairs[i].~Pair();
+		}
+		FREE_ARRAY<Pair>(pairs);
+		pairs = new_pairs;
+	}
+
+	Pair* pairs;
+	int capacity;
+	int length;
+};