bloby-bot 0.27.0 → 0.27.1

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

@@ -1,383 +0,0 @@
-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;
-	const bool safe_ints = stmt->safe_ints;
-	const char mode = stmt->mode;
-
-#if !defined(NODE_MODULE_VERSION) || NODE_MODULE_VERSION < 127
-	bool js_error = false;
-	uint32_t row_count = 0;
-	v8::Local<v8::Array> result = v8::Array::New(isolate, 0);
-
-	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();
-#else
-	v8::LocalVector<v8::Value> rows(isolate);
-	rows.reserve(8);
-
-	if (mode == Data::FLAT) {
-		RowBuilder rowBuilder(isolate, handle, safe_ints);
-		while (sqlite3_step(handle) == SQLITE_ROW) {
-			rows.emplace_back(rowBuilder.GetRowJS());
-		}
-	} else {
-		while (sqlite3_step(handle) == SQLITE_ROW) {
-			rows.emplace_back(Data::GetRowJS(isolate, ctx, handle, safe_ints, mode));
-		}
-	}
-
-	if (sqlite3_reset(handle) == SQLITE_OK) {
-		if (rows.size() > 0xffffffff) {
-			ThrowRangeError("Array overflow (too many rows returned)");
-			db->GetState()->was_js_error = true;
-		} else {
-			STATEMENT_RETURN(v8::Array::New(isolate, rows.data(), rows.size()));
-		}
-	}
-	STATEMENT_THROW();
-#endif
-}
-
-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;
-
-#if !defined(NODE_MODULE_VERSION) || NODE_MODULE_VERSION < 127
-	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);
-#else
-	v8::LocalVector<v8::Name> keys(isolate);
-	keys.reserve(5);
-	keys.emplace_back(addon->cs.name.Get(isolate).As<v8::Name>());
-	keys.emplace_back(addon->cs.column.Get(isolate).As<v8::Name>());
-	keys.emplace_back(addon->cs.table.Get(isolate).As<v8::Name>());
-	keys.emplace_back(addon->cs.database.Get(isolate).As<v8::Name>());
-	keys.emplace_back(addon->cs.type.Get(isolate).As<v8::Name>());
-
-	int column_count = sqlite3_column_count(stmt->handle);
-	v8::LocalVector<v8::Value> columns(isolate);
-	columns.reserve(column_count);
-
-	for (int i = 0; i < column_count; ++i) {
-		v8::LocalVector<v8::Value> values(isolate);
-		keys.reserve(5);
-		values.emplace_back(
-			InternalizedFromUtf8OrNull(isolate, sqlite3_column_name(stmt->handle, i), -1)
-		);
-		values.emplace_back(
-			InternalizedFromUtf8OrNull(isolate, sqlite3_column_origin_name(stmt->handle, i), -1)
-		);
-		values.emplace_back(
-			InternalizedFromUtf8OrNull(isolate, sqlite3_column_table_name(stmt->handle, i), -1)
-		);
-		values.emplace_back(
-			InternalizedFromUtf8OrNull(isolate, sqlite3_column_database_name(stmt->handle, i), -1)
-		);
-		values.emplace_back(
-			InternalizedFromUtf8OrNull(isolate, sqlite3_column_decltype(stmt->handle, i), -1)
-		);
-		columns.emplace_back(
-			v8::Object::New(isolate,
-				GET_PROTOTYPE(v8::Object::New(isolate)),
-				keys.data(),
-				values.data(),
-				keys.size()
-			)
-		);
-	}
-
-	info.GetReturnValue().Set(
-		v8::Array::New(isolate, columns.data(), columns.size())
-	);
-#endif
-}
-
-NODE_GETTER(Statement::JS_busy) {
-	Statement* stmt = Unwrap<Statement>(PROPERTY_HOLDER(info));
-	info.GetReturnValue().Set(stmt->alive && stmt->locked);
-}

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

@@ -1,58 +0,0 @@
-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;
-};

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

@@ -1,73 +0,0 @@
-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 v8::Local<v8::String> GetName(v8::Isolate* isolate) {
-				return name.Get(isolate);
-			}
-
-		private:
-
-			explicit Pair(v8::Isolate* isolate, const char* name, int index)
-				: name(isolate, InternalizedFromUtf8(isolate, name, -1)), index(index) {}
-
-			explicit Pair(v8::Isolate* isolate, Pair* pair)
-				: name(isolate, pair->name), index(pair->index) {}
-
-			const v8::Global<v8::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(v8::Isolate* isolate, const char* name, int index) {
-		assert(name != NULL);
-		if (capacity == length) Grow(isolate);
-		new (pairs + length++) Pair(isolate, name, index);
-	}
-
-private:
-
-	void Grow(v8::Isolate* isolate) {
-		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(isolate, pairs + i);
-			pairs[i].~Pair();
-		}
-		FREE_ARRAY<Pair>(pairs);
-		pairs = new_pairs;
-	}
-
-	Pair* pairs;
-	int capacity;
-	int length;
-};

package/workspace/node_modules/better-sqlite3/src/util/binder.cpp

@@ -1,193 +0,0 @@
-class Binder {
-public:
-
-	explicit Binder(sqlite3_stmt* _handle) {
-		handle = _handle;
-		param_count = sqlite3_bind_parameter_count(_handle);
-		anon_index = 0;
-		success = true;
-	}
-
-	bool Bind(NODE_ARGUMENTS info, int argc, Statement* stmt) {
-		assert(anon_index == 0);
-		Result result = BindArgs(info, argc, stmt);
-		if (success && result.count != param_count) {
-			if (result.count < param_count) {
-				if (!result.bound_object && stmt->GetBindMap(OnlyIsolate)->GetSize()) {
-					Fail(ThrowTypeError, "Missing named parameters");
-				} else {
-					Fail(ThrowRangeError, "Too few parameter values were provided");
-				}
-			} else {
-				Fail(ThrowRangeError, "Too many parameter values were provided");
-			}
-		}
-		return success;
-	}
-
-private:
-
-	struct Result {
-		int count;
-		bool bound_object;
-	};
-
-	static bool IsPlainObject(v8::Isolate* isolate, v8::Local<v8::Object> obj) {
-		v8::Local<v8::Value> proto = GET_PROTOTYPE(obj);
-		v8::Local<v8::Context> ctx = obj->GetCreationContext().ToLocalChecked();
-		ctx->Enter();
-		v8::Local<v8::Value> baseProto = GET_PROTOTYPE(v8::Object::New(isolate));
-		ctx->Exit();
-		return proto->StrictEquals(baseProto) || proto->StrictEquals(v8::Null(isolate));
-	}
-
-	void Fail(void (*Throw)(const char* _), const char* message) {
-		assert(success == true);
-		assert((Throw == NULL) == (message == NULL));
-		assert(Throw == ThrowError || Throw == ThrowTypeError || Throw == ThrowRangeError || Throw == NULL);
-		if (Throw) Throw(message);
-		success = false;
-	}
-
-	int NextAnonIndex() {
-		while (sqlite3_bind_parameter_name(handle, ++anon_index) != NULL) {}
-		return anon_index;
-	}
-
-	// Binds the value at the given index or throws an appropriate error.
-	void BindValue(v8::Isolate* isolate, v8::Local<v8::Value> value, int index) {
-		int status = Data::BindValueFromJS(isolate, handle, index, value);
-		if (status != SQLITE_OK) {
-			switch (status) {
-				case -1:
-					return Fail(ThrowTypeError, "SQLite3 can only bind numbers, strings, bigints, buffers, and null");
-				case SQLITE_TOOBIG:
-					return Fail(ThrowRangeError, "The bound string, buffer, or bigint is too big");
-				case SQLITE_RANGE:
-					return Fail(ThrowRangeError, "Too many parameter values were provided");
-				case SQLITE_NOMEM:
-					return Fail(ThrowError, "Out of memory");
-				default:
-					return Fail(ThrowError, "An unexpected error occured while trying to bind parameters");
-			}
-			assert(false);
-		}
-	}
-
-	// Binds each value in the array or throws an appropriate error.
-	// The number of successfully bound parameters is returned.
-	int BindArray(v8::Isolate* isolate, v8::Local<v8::Array> arr) {
-		UseContext;
-		uint32_t length = arr->Length();
-		if (length > INT_MAX) {
-			Fail(ThrowRangeError, "Too many parameter values were provided");
-			return 0;
-		}
-		int len = static_cast<int>(length);
-		for (int i = 0; i < len; ++i) {
-			v8::MaybeLocal<v8::Value> maybeValue = arr->Get(ctx, i);
-			if (maybeValue.IsEmpty()) {
-				Fail(NULL, NULL);
-				return i;
-			}
-			BindValue(isolate, maybeValue.ToLocalChecked(), NextAnonIndex());
-			if (!success) {
-				return i;
-			}
-		}
-		return len;
-	}
-
-	// Binds all named parameters using the values found in the given object.
-	// The number of successfully bound parameters is returned.
-	// If a named parameter is missing from the object, an error is thrown.
-	// This should only be invoked once per instance.
-	int BindObject(v8::Isolate* isolate, v8::Local<v8::Object> obj, Statement* stmt) {
-		UseContext;
-		BindMap* bind_map = stmt->GetBindMap(isolate);
-		BindMap::Pair* pairs = bind_map->GetPairs();
-		int len = bind_map->GetSize();
-
-		for (int i = 0; i < len; ++i) {
-			v8::Local<v8::String> key = pairs[i].GetName(isolate);
-
-			// Check if the named parameter was provided.
-			v8::Maybe<bool> has_property = obj->HasOwnProperty(ctx, key);
-			if (has_property.IsNothing()) {
-				Fail(NULL, NULL);
-				return i;
-			}
-			if (!has_property.FromJust()) {
-				v8::String::Utf8Value param_name(isolate, key);
-				Fail(ThrowRangeError, (std::string("Missing named parameter \"") + *param_name + "\"").c_str());
-				return i;
-			}
-
-			// Get the current property value.
-			v8::MaybeLocal<v8::Value> maybeValue = obj->Get(ctx, key);
-			if (maybeValue.IsEmpty()) {
-				Fail(NULL, NULL);
-				return i;
-			}
-
-			BindValue(isolate, maybeValue.ToLocalChecked(), pairs[i].GetIndex());
-			if (!success) {
-				return i;
-			}
-		}
-
-		return len;
-	}
-
-	// Binds all parameters using the values found in the arguments object.
-	// Anonymous parameter values can be directly in the arguments object or in an Array.
-	// Named parameter values can be provided in a plain Object argument.
-	// Only one plain Object argument may be provided.
-	// If an error occurs, an appropriate error is thrown.
-	// The return value is a struct indicating how many parameters were successfully bound
-	// and whether or not it tried to bind an object.
-	Result BindArgs(NODE_ARGUMENTS info, int argc, Statement* stmt) {
-		UseIsolate;
-		int count = 0;
-		bool bound_object = false;
-
-		for (int i = 0; i < argc; ++i) {
-			v8::Local<v8::Value> arg = info[i];
-
-			if (arg->IsArray()) {
-				count += BindArray(isolate, arg.As<v8::Array>());
-				if (!success) break;
-				continue;
-			}
-
-			if (arg->IsObject() && !node::Buffer::HasInstance(arg)) {
-				v8::Local<v8::Object> obj = arg.As<v8::Object>();
-				if (IsPlainObject(isolate, obj)) {
-					if (bound_object) {
-						Fail(ThrowTypeError, "You cannot specify named parameters in two different objects");
-						break;
-					}
-					bound_object = true;
-
-					count += BindObject(isolate, obj, stmt);
-					if (!success) break;
-					continue;
-				} else if (stmt->GetBindMap(isolate)->GetSize()) {
-					Fail(ThrowTypeError, "Named parameters can only be passed within plain objects");
-					break;
-				}
-			}
-
-			BindValue(isolate, arg, NextAnonIndex());
-			if (!success) break;
-			count += 1;
-		}
-
-		return { count, bound_object };
-	}
-
-	sqlite3_stmt* handle;
-	int param_count;
-	int anon_index; // This value should only be used by NextAnonIndex()
-	bool success; // This value should only be set by Fail()
-};