karajan-code 3.4.1 → 3.4.2

package/node_modules/better-sqlite3/src/util/custom-table.cpp

@@ -1,409 +0,0 @@
-class CustomTable {
-public:
-
-	explicit CustomTable(
-		v8::Isolate* isolate,
-		Database* db,
-		const char* name,
-		v8::Local<v8::Function> factory
-	) :
-		addon(db->GetAddon()),
-		isolate(isolate),
-		db(db),
-		name(name),
-		factory(isolate, factory) {}
-
-	static void Destructor(void* self) {
-		delete static_cast<CustomTable*>(self);
-	}
-
-	static sqlite3_module MODULE;
-	static sqlite3_module EPONYMOUS_MODULE;
-
-private:
-
-	// This nested class is instantiated on each CREATE VIRTUAL TABLE statement.
-	class VTab { friend class CustomTable;
-		explicit VTab(
-			CustomTable* parent,
-			v8::Local<v8::Function> generator,
-			std::vector<std::string> parameter_names,
-			bool safe_ints
-		) :
-			parent(parent),
-			parameter_count(parameter_names.size()),
-			safe_ints(safe_ints),
-			generator(parent->isolate, generator),
-			parameter_names(parameter_names) {
-			((void)base);
-		}
-
-		static inline CustomTable::VTab* Upcast(sqlite3_vtab* vtab) {
-			return reinterpret_cast<VTab*>(vtab);
-		}
-
-		inline sqlite3_vtab* Downcast() {
-			return reinterpret_cast<sqlite3_vtab*>(this);
-		}
-
-		sqlite3_vtab base;
-		CustomTable * const parent;
-		const int parameter_count;
-		const bool safe_ints;
-		const v8::Global<v8::Function> generator;
-		const std::vector<std::string> parameter_names;
-	};
-
-	// This nested class is instantiated each time a virtual table is scanned.
-	class Cursor { friend class CustomTable;
-		static inline CustomTable::Cursor* Upcast(sqlite3_vtab_cursor* cursor) {
-			return reinterpret_cast<Cursor*>(cursor);
-		}
-
-		inline sqlite3_vtab_cursor* Downcast() {
-			return reinterpret_cast<sqlite3_vtab_cursor*>(this);
-		}
-
-		inline CustomTable::VTab* GetVTab() {
-			return VTab::Upcast(base.pVtab);
-		}
-
-		sqlite3_vtab_cursor base;
-		v8::Global<v8::Object> iterator;
-		v8::Global<v8::Function> next;
-		v8::Global<v8::Array> row;
-		bool done;
-		sqlite_int64 rowid;
-	};
-
-	// This nested class is used by Data::ResultValueFromJS to report errors.
-	class TempDataConverter : DataConverter { friend class CustomTable;
-		explicit TempDataConverter(CustomTable* parent) :
-			parent(parent),
-			status(SQLITE_OK) {}
-
-		void PropagateJSError(sqlite3_context* invocation) {
-			status = SQLITE_ERROR;
-			parent->PropagateJSError();
-		}
-
-		std::string GetDataErrorPrefix() {
-			return std::string("Virtual table module \"") + parent->name + "\" yielded";
-		}
-
-		CustomTable * const parent;
-		int status;
-	};
-
-	// Although this function does nothing, we cannot use xConnect directly,
-	// because that would cause SQLite to register an eponymous virtual table.
-	static int xCreate(sqlite3* db_handle, void* _self, int argc, const char* const * argv, sqlite3_vtab** output, char** errOutput) {
-		return xConnect(db_handle, _self, argc, argv, output, errOutput);
-	}
-
-	// This method uses the factory function to instantiate a new virtual table.
-	static int xConnect(sqlite3* db_handle, void* _self, int argc, const char* const * argv, sqlite3_vtab** output, char** errOutput) {
-		CustomTable* self = static_cast<CustomTable*>(_self);
-		v8::Isolate* isolate = self->isolate;
-		v8::HandleScope scope(isolate);
-		UseContext;
-
-		v8::Local<v8::Value>* args = ALLOC_ARRAY<v8::Local<v8::Value>>(argc);
-		for (int i = 0; i < argc; ++i) {
-			args[i] = StringFromUtf8(isolate, argv[i], -1);
-		}
-
-		// Run the factory function to receive a new virtual table definition.
-		v8::MaybeLocal<v8::Value> maybeReturnValue = self->factory.Get(isolate)->Call(ctx, v8::Undefined(isolate), argc, args);
-		delete[] args;
-
-		if (maybeReturnValue.IsEmpty()) {
-			self->PropagateJSError();
-			return SQLITE_ERROR;
-		}
-
-		// Extract each part of the virtual table definition.
-		v8::Local<v8::Array> returnValue = maybeReturnValue.ToLocalChecked().As<v8::Array>();
-		v8::Local<v8::String> sqlString = returnValue->Get(ctx, 0).ToLocalChecked().As<v8::String>();
-		v8::Local<v8::Function> generator = returnValue->Get(ctx, 1).ToLocalChecked().As<v8::Function>();
-		v8::Local<v8::Array> parameterNames = returnValue->Get(ctx, 2).ToLocalChecked().As<v8::Array>();
-		int safe_ints = returnValue->Get(ctx, 3).ToLocalChecked().As<v8::Int32>()->Value();
-		bool direct_only = returnValue->Get(ctx, 4).ToLocalChecked().As<v8::Boolean>()->Value();
-
-		v8::String::Utf8Value sql(isolate, sqlString);
-		safe_ints = safe_ints < 2 ? safe_ints : static_cast<int>(self->db->GetState()->safe_ints);
-
-		// Copy the parameter names into a std::vector.
-		std::vector<std::string> parameter_names;
-		for (int i = 0, len = parameterNames->Length(); i < len; ++i) {
-			v8::Local<v8::String> parameterName = parameterNames->Get(ctx, i).ToLocalChecked().As<v8::String>();
-			v8::String::Utf8Value parameter_name(isolate, parameterName);
-			parameter_names.emplace_back(*parameter_name);
-		}
-
-		// Pass our SQL table definition to SQLite (this should never fail).
-		if (sqlite3_declare_vtab(db_handle, *sql) != SQLITE_OK) {
-			*errOutput = sqlite3_mprintf("failed to declare virtual table \"%s\"", argv[2]);
-			return SQLITE_ERROR;
-		}
-		if (direct_only && sqlite3_vtab_config(db_handle, SQLITE_VTAB_DIRECTONLY) != SQLITE_OK) {
-			*errOutput = sqlite3_mprintf("failed to configure virtual table \"%s\"", argv[2]);
-			return SQLITE_ERROR;
-		}
-
-		// Return the successfully created virtual table.
-		*output = (new VTab(self, generator, parameter_names, safe_ints))->Downcast();
-		return SQLITE_OK;
-	}
-
-	static int xDisconnect(sqlite3_vtab* vtab) {
-		delete VTab::Upcast(vtab);
-		return SQLITE_OK;
-	}
-
-	static int xOpen(sqlite3_vtab* vtab, sqlite3_vtab_cursor** output) {
-		*output = (new Cursor())->Downcast();
-		return SQLITE_OK;
-	}
-
-	static int xClose(sqlite3_vtab_cursor* cursor) {
-		delete Cursor::Upcast(cursor);
-		return SQLITE_OK;
-	}
-
-	// This method uses a fresh cursor to start a new scan of a virtual table.
-	// The args and idxNum are provided by xBestIndex (idxStr is unused).
-	// idxNum is a bitmap that provides the proper indices of the received args.
-	static int xFilter(sqlite3_vtab_cursor* _cursor, int idxNum, const char* idxStr, int argc, sqlite3_value** argv) {
-		Cursor* cursor = Cursor::Upcast(_cursor);
-		VTab* vtab = cursor->GetVTab();
-		CustomTable* self = vtab->parent;
-		Addon* addon = self->addon;
-		v8::Isolate* isolate = self->isolate;
-		v8::HandleScope scope(isolate);
-		UseContext;
-
-		// Convert the SQLite arguments into JavaScript arguments. Note that
-		// the values in argv may be in the wrong order, so we fix that here.
-		v8::Local<v8::Value> args_fast[4];
-		v8::Local<v8::Value>* args = NULL;
-		int parameter_count = vtab->parameter_count;
-		if (parameter_count != 0) {
-			args = parameter_count <= 4 ? args_fast : ALLOC_ARRAY<v8::Local<v8::Value>>(parameter_count);
-			int argn = 0;
-			bool safe_ints = vtab->safe_ints;
-			for (int i = 0; i < parameter_count; ++i) {
-				if (idxNum & 1 << i) {
-					args[i] = Data::GetValueJS(isolate, argv[argn++], safe_ints);
-					// If any arguments are NULL, the result set is necessarily
-					// empty, so don't bother to run the generator function.
-					if (args[i]->IsNull()) {
-						if (args != args_fast) delete[] args;
-						cursor->done = true;
-						return SQLITE_OK;
-					}
-				} else {
-					args[i] = v8::Undefined(isolate);
-				}
-			}
-		}
-
-		// Invoke the generator function to create a new iterator.
-		v8::MaybeLocal<v8::Value> maybeIterator = vtab->generator.Get(isolate)->Call(ctx, v8::Undefined(isolate), parameter_count, args);
-		if (args != args_fast) delete[] args;
-
-		if (maybeIterator.IsEmpty()) {
-			self->PropagateJSError();
-			return SQLITE_ERROR;
-		}
-
-		// Store the iterator and its next() method; we'll be using it a lot.
-		v8::Local<v8::Object> iterator = maybeIterator.ToLocalChecked().As<v8::Object>();
-		v8::Local<v8::Function> next = iterator->Get(ctx, addon->cs.next.Get(isolate)).ToLocalChecked().As<v8::Function>();
-		cursor->iterator.Reset(isolate, iterator);
-		cursor->next.Reset(isolate, next);
-		cursor->rowid = 0;
-
-		// Advance the iterator/cursor to the first row.
-		return xNext(cursor->Downcast());
-	}
-
-	// This method advances a virtual table's cursor to the next row.
-	// SQLite will call this method repeatedly, driving the generator function.
-	static int xNext(sqlite3_vtab_cursor* _cursor) {
-		Cursor* cursor = Cursor::Upcast(_cursor);
-		CustomTable* self = cursor->GetVTab()->parent;
-		Addon* addon = self->addon;
-		v8::Isolate* isolate = self->isolate;
-		v8::HandleScope scope(isolate);
-		UseContext;
-
-		v8::Local<v8::Object> iterator = cursor->iterator.Get(isolate);
-		v8::Local<v8::Function> next = cursor->next.Get(isolate);
-
-		v8::MaybeLocal<v8::Value> maybeRecord = next->Call(ctx, iterator, 0, NULL);
-		if (maybeRecord.IsEmpty()) {
-			self->PropagateJSError();
-			return SQLITE_ERROR;
-		}
-
-		v8::Local<v8::Object> record = maybeRecord.ToLocalChecked().As<v8::Object>();
-		bool done = record->Get(ctx, addon->cs.done.Get(isolate)).ToLocalChecked().As<v8::Boolean>()->Value();
-		if (!done) {
-			cursor->row.Reset(isolate, record->Get(ctx, addon->cs.value.Get(isolate)).ToLocalChecked().As<v8::Array>());
-		}
-		cursor->done = done;
-		cursor->rowid += 1;
-
-		return SQLITE_OK;
-	}
-
-	// If this method returns 1, SQLite will stop scanning the virtual table.
-	static int xEof(sqlite3_vtab_cursor* cursor) {
-		return Cursor::Upcast(cursor)->done;
-	}
-
-	// This method extracts some column from the cursor's current row.
-	static int xColumn(sqlite3_vtab_cursor* _cursor, sqlite3_context* invocation, int column) {
-		Cursor* cursor = Cursor::Upcast(_cursor);
-		CustomTable* self = cursor->GetVTab()->parent;
-		TempDataConverter temp_data_converter(self);
-		v8::Isolate* isolate = self->isolate;
-		v8::HandleScope scope(isolate);
-
-		v8::Local<v8::Array> row = cursor->row.Get(isolate);
-		v8::MaybeLocal<v8::Value> maybeColumnValue = row->Get(OnlyContext, column);
-		if (maybeColumnValue.IsEmpty()) {
-			temp_data_converter.PropagateJSError(NULL);
-		} else {
-			Data::ResultValueFromJS(isolate, invocation, maybeColumnValue.ToLocalChecked(), &temp_data_converter);
-		}
-		return temp_data_converter.status;
-	}
-
-	// This method outputs the rowid of the cursor's current row.
-	static int xRowid(sqlite3_vtab_cursor* cursor, sqlite_int64* output) {
-		*output = Cursor::Upcast(cursor)->rowid;
-		return SQLITE_OK;
-	}
-
-	// This method tells SQLite how to *plan* queries on our virtual table.
-	// It gets invoked (typically multiple times) during db.prepare().
-	static int xBestIndex(sqlite3_vtab* vtab, sqlite3_index_info* output) {
-		int parameter_count = VTab::Upcast(vtab)->parameter_count;
-		int argument_count = 0;
-		std::vector<std::pair<int, int>> forwarded;
-
-		for (int i = 0, len = output->nConstraint; i < len; ++i) {
-			auto item = output->aConstraint[i];
-
-			// The SQLITE_INDEX_CONSTRAINT_LIMIT and SQLITE_INDEX_CONSTRAINT_OFFSET
-			// operators have no left-hand operand, and so for those operators the
-			// corresponding item.iColumn is meaningless.
-			// We don't care those constraints.
-			if (item.op == SQLITE_INDEX_CONSTRAINT_LIMIT || item.op == SQLITE_INDEX_CONSTRAINT_OFFSET) {
-				continue;
-			}
-			// We only care about constraints on parameters, not regular columns.
-			if (item.iColumn >= 0 && item.iColumn < parameter_count) {
-				if (item.op != SQLITE_INDEX_CONSTRAINT_EQ) {
-					sqlite3_free(vtab->zErrMsg);
-					vtab->zErrMsg = sqlite3_mprintf(
-						"virtual table parameter \"%s\" can only be constrained by the '=' operator",
-						VTab::Upcast(vtab)->parameter_names.at(item.iColumn).c_str());
-					return SQLITE_ERROR;
-				}
-				if (!item.usable) {
-					// Don't allow SQLite to make plans that ignore arguments.
-					// Otherwise, a user could pass arguments, but then they
-					// could appear undefined in the generator function.
-					return SQLITE_CONSTRAINT;
-				}
-				forwarded.emplace_back(item.iColumn, i);
-			}
-		}
-
-		// Tell SQLite to forward arguments to xFilter.
-		std::sort(forwarded.begin(), forwarded.end());
-		for (std::pair<int, int> pair : forwarded) {
-			int bit = 1 << pair.first;
-			if (!(output->idxNum & bit)) {
-				output->idxNum |= bit;
-				output->aConstraintUsage[pair.second].argvIndex = ++argument_count;
-				output->aConstraintUsage[pair.second].omit = 1;
-			}
-		}
-
-		// Use a very high estimated cost so SQLite is not tempted to invoke the
-		// generator function within a loop, if it can be avoided.
-		output->estimatedCost = output->estimatedRows = 1000000000 / (argument_count + 1);
-		return SQLITE_OK;
-	}
-
-	void PropagateJSError() {
-		assert(db->GetState()->was_js_error == false);
-		db->GetState()->was_js_error = true;
-	}
-
-	Addon* const addon;
-	v8::Isolate* const isolate;
-	Database* const db;
-	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 */
-};

package/node_modules/better-sqlite3/src/util/data-converter.cpp

@@ -1,17 +0,0 @@
-class DataConverter {
-public:
-
-	void ThrowDataConversionError(sqlite3_context* invocation, bool isBigInt) {
-		if (isBigInt) {
-			ThrowRangeError((GetDataErrorPrefix() + " a bigint that was too big").c_str());
-		} else {
-			ThrowTypeError((GetDataErrorPrefix() + " an invalid value").c_str());
-		}
-		PropagateJSError(invocation);
-	}
-
-protected:
-
-	virtual void PropagateJSError(sqlite3_context* invocation) = 0;
-	virtual std::string GetDataErrorPrefix() = 0;
-};

package/node_modules/better-sqlite3/src/util/data.cpp

@@ -1,194 +0,0 @@
-#define JS_VALUE_TO_SQLITE(to, value, isolate, ...)                            \
-	if (value->IsNumber()) {                                                   \
-		return sqlite3_##to##_double(                                          \
-			__VA_ARGS__,                                                       \
-			value.As<v8::Number>()->Value()                                    \
-		);                                                                     \
-	} else if (value->IsBigInt()) {                                            \
-		bool lossless;                                                         \
-		int64_t v = value.As<v8::BigInt>()->Int64Value(&lossless);             \
-		if (lossless) {                                                        \
-			return sqlite3_##to##_int64(__VA_ARGS__, v);                       \
-		}                                                                      \
-	} else if (value->IsString()) {                                            \
-		v8::String::Utf8Value utf8(isolate, value.As<v8::String>());           \
-		return sqlite3_##to##_text(                                            \
-			__VA_ARGS__,                                                       \
-			*utf8,                                                             \
-			utf8.length(),                                                     \
-			SQLITE_TRANSIENT                                                   \
-		);                                                                     \
-	} else if (node::Buffer::HasInstance(value)) {                             \
-		const char* data = node::Buffer::Data(value);                          \
-		return sqlite3_##to##_blob(                                            \
-			__VA_ARGS__,                                                       \
-			data ? data : "",                                                  \
-			node::Buffer::Length(value),                                       \
-			SQLITE_TRANSIENT                                                   \
-		);                                                                     \
-	} else if (value->IsNull() || value->IsUndefined()) {                      \
-		return sqlite3_##to##_null(__VA_ARGS__);                               \
-	}
-
-#define SQLITE_VALUE_TO_JS(from, isolate, safe_ints, ...)                      \
-	switch (sqlite3_##from##_type(__VA_ARGS__)) {                              \
-	case SQLITE_INTEGER:                                                       \
-		if (safe_ints) {                                                       \
-			return v8::BigInt::New(                                            \
-				isolate,                                                       \
-				sqlite3_##from##_int64(__VA_ARGS__)                            \
-			);                                                                 \
-		}                                                                      \
-	case SQLITE_FLOAT:                                                         \
-		return v8::Number::New(                                                \
-			isolate,                                                           \
-			sqlite3_##from##_double(__VA_ARGS__)                               \
-		);                                                                     \
-	case SQLITE_TEXT:                                                          \
-		return StringFromUtf8(                                                 \
-			isolate,                                                           \
-			reinterpret_cast<const char*>(sqlite3_##from##_text(__VA_ARGS__)), \
-			sqlite3_##from##_bytes(__VA_ARGS__)                                \
-		);                                                                     \
-	case SQLITE_BLOB:                                                          \
-		return node::Buffer::Copy(                                             \
-			isolate,                                                           \
-			static_cast<const char*>(sqlite3_##from##_blob(__VA_ARGS__)),      \
-			sqlite3_##from##_bytes(__VA_ARGS__)                                \
-		).ToLocalChecked();                                                    \
-	default:                                                                   \
-		assert(sqlite3_##from##_type(__VA_ARGS__) == SQLITE_NULL);             \
-		return v8::Null(isolate);                                              \
-	}                                                                          \
-	assert(false);
-
-namespace Data {
-
-	static const char FLAT = 0;
-	static const char PLUCK = 1;
-	static const char EXPAND = 2;
-	static const char RAW = 3;
-
-	v8::Local<v8::Value> GetValueJS(v8::Isolate* isolate, sqlite3_stmt* handle, int column, bool safe_ints) {
-		SQLITE_VALUE_TO_JS(column, isolate, safe_ints, handle, column);
-	}
-
-	v8::Local<v8::Value> GetValueJS(v8::Isolate* isolate, sqlite3_value* value, bool safe_ints) {
-		SQLITE_VALUE_TO_JS(value, isolate, safe_ints, value);
-	}
-
-	v8::Local<v8::Value> GetExpandedRowJS(v8::Isolate* isolate, v8::Local<v8::Context> ctx, sqlite3_stmt* handle, bool safe_ints) {
-		v8::Local<v8::Object> row = v8::Object::New(isolate);
-		int column_count = sqlite3_column_count(handle);
-		for (int i = 0; i < column_count; ++i) {
-			const char* table_raw = sqlite3_column_table_name(handle, i);
-			v8::Local<v8::String> table = InternalizedFromUtf8(isolate, table_raw == NULL ? "$" : table_raw, -1);
-			v8::Local<v8::String> column = InternalizedFromUtf8(isolate, sqlite3_column_name(handle, i), -1);
-			v8::Local<v8::Value> value = Data::GetValueJS(isolate, handle, i, safe_ints);
-			if (row->HasOwnProperty(ctx, table).FromJust()) {
-				row->Get(ctx, table).ToLocalChecked().As<v8::Object>()->Set(ctx, column, value).FromJust();
-			} else {
-				v8::Local<v8::Object> nested = v8::Object::New(isolate);
-				row->Set(ctx, table, nested).FromJust();
-				nested->Set(ctx, column, value).FromJust();
-			}
-		}
-		return row;
-	}
-
-#if !defined(NODE_MODULE_VERSION) || NODE_MODULE_VERSION < 127
-
-	v8::Local<v8::Value> GetFlatRowJS(v8::Isolate* isolate, v8::Local<v8::Context> ctx, sqlite3_stmt* handle, bool safe_ints) {
-		v8::Local<v8::Object> row = v8::Object::New(isolate);
-		int column_count = sqlite3_column_count(handle);
-		for (int i = 0; i < column_count; ++i) {
-			row->Set(ctx,
-				InternalizedFromUtf8(isolate, sqlite3_column_name(handle, i), -1),
-				Data::GetValueJS(isolate, handle, i, safe_ints)
-			).FromJust();
-		}
-		return row;
-	}
-
-	v8::Local<v8::Value> GetRawRowJS(v8::Isolate* isolate, v8::Local<v8::Context> ctx, sqlite3_stmt* handle, bool safe_ints) {
-		v8::Local<v8::Array> row = v8::Array::New(isolate);
-		int column_count = sqlite3_column_count(handle);
-		for (int i = 0; i < column_count; ++i) {
-			row->Set(ctx, i, Data::GetValueJS(isolate, handle, i, safe_ints)).FromJust();
-		}
-		return row;
-	}
-
-	v8::Local<v8::Value> GetRowJS(v8::Isolate* isolate, v8::Local<v8::Context> ctx, sqlite3_stmt* handle, bool safe_ints, char mode) {
-		if (mode == FLAT) return GetFlatRowJS(isolate, ctx, handle, safe_ints);
-		if (mode == PLUCK) return GetValueJS(isolate, handle, 0, safe_ints);
-		if (mode == EXPAND) return GetExpandedRowJS(isolate, ctx, handle, safe_ints);
-		if (mode == RAW) return GetRawRowJS(isolate, ctx, handle, safe_ints);
-		assert(false);
-		return v8::Local<v8::Value>();
-	}
-
-#else
-
-	v8::Local<v8::Value> GetFlatRowJS(v8::Isolate* isolate, sqlite3_stmt* handle, bool safe_ints) {
-		int column_count = sqlite3_column_count(handle);
-		v8::LocalVector<v8::Name> keys(isolate);
-		v8::LocalVector<v8::Value> values(isolate);
-		keys.reserve(column_count);
-		values.reserve(column_count);
-		for (int i = 0; i < column_count; ++i) {
-			keys.emplace_back(
-				InternalizedFromUtf8(isolate, sqlite3_column_name(handle, i), -1).As<v8::Name>()
-			);
-			values.emplace_back(
-				Data::GetValueJS(isolate, handle, i, safe_ints)
-			);
-		}
-		return v8::Object::New(
-			isolate,
-			GET_PROTOTYPE(v8::Object::New(isolate)),
-			keys.data(),
-			values.data(),
-			column_count
-		);
-	}
-
-	v8::Local<v8::Value> GetRawRowJS(v8::Isolate* isolate, sqlite3_stmt* handle, bool safe_ints) {
-		int column_count = sqlite3_column_count(handle);
-		v8::LocalVector<v8::Value> row(isolate);
-		row.reserve(column_count);
-		for (int i = 0; i < column_count; ++i) {
-			row.emplace_back(Data::GetValueJS(isolate, handle, i, safe_ints));
-		}
-		return v8::Array::New(isolate, row.data(), row.size());
-	}
-
-	v8::Local<v8::Value> GetRowJS(v8::Isolate* isolate, v8::Local<v8::Context> ctx, sqlite3_stmt* handle, bool safe_ints, char mode) {
-		if (mode == FLAT) return GetFlatRowJS(isolate, handle, safe_ints);
-		if (mode == PLUCK) return GetValueJS(isolate, handle, 0, safe_ints);
-		if (mode == EXPAND) return GetExpandedRowJS(isolate, ctx, handle, safe_ints);
-		if (mode == RAW) return GetRawRowJS(isolate, handle, safe_ints);
-		assert(false);
-		return v8::Local<v8::Value>();
-	}
-
-#endif
-
-	void GetArgumentsJS(v8::Isolate* isolate, v8::Local<v8::Value>* out, sqlite3_value** values, int argument_count, bool safe_ints) {
-		assert(argument_count > 0);
-		for (int i = 0; i < argument_count; ++i) {
-			out[i] = Data::GetValueJS(isolate, values[i], safe_ints);
-		}
-	}
-
-	int BindValueFromJS(v8::Isolate* isolate, sqlite3_stmt* handle, int index, v8::Local<v8::Value> value) {
-		JS_VALUE_TO_SQLITE(bind, value, isolate, handle, index);
-		return value->IsBigInt() ? SQLITE_TOOBIG : -1;
-	}
-
-	void ResultValueFromJS(v8::Isolate* isolate, sqlite3_context* invocation, v8::Local<v8::Value> value, DataConverter* converter) {
-		JS_VALUE_TO_SQLITE(result, value, isolate, invocation);
-		converter->ThrowDataConversionError(invocation, value->IsBigInt());
-	}
-
-}