better-sqlite3-multiple-ciphers 12.4.1 → 12.5.0

package/src/util/data.cpp

@@ -1,194 +1,194 @@
-#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,
-			v8::Object::New(isolate)->GetPrototype(),
-			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());
-	}
-
-}
+#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());
+	}
+
+}

package/src/util/macros.cpp

@@ -1,63 +1,70 @@
-#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
+#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)
+
+#if defined(V8_MAJOR_VERSION) && V8_MAJOR_VERSION >= 13
+// v8::Object::GetPrototype has been deprecated. See http://crbug.com/333672197
+#define GET_PROTOTYPE(obj) ((obj)->GetPrototypeV2())
+#else
+#define GET_PROTOTYPE(obj) ((obj)->GetPrototype())
+#endif
+
+#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

package/src/util/row-builder.cpp

@@ -1,49 +1,49 @@
-class RowBuilder {
-public:
-
-	explicit RowBuilder(
-		v8::Isolate* isolate,
-		sqlite3_stmt* handle,
-		bool safe_ints
-	) :
-		isolate(isolate),
-		handle(handle),
-		column_count(-1),
-		safe_ints(safe_ints),
-		keys(isolate) {}
-
-	v8::Local<v8::Value> GetRowJS() {
-		if (column_count < 0) {
-			column_count = sqlite3_column_count(handle);
-			keys.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>()
-				);
-			}
-		}
-
-		v8::LocalVector<v8::Value> values(isolate);
-		values.reserve(column_count);
-		for (int i = 0; i < column_count; ++i) {
-			values.emplace_back(
-				Data::GetValueJS(isolate, handle, i, safe_ints)
-			);
-		}
-
-		return v8::Object::New(isolate,
-			v8::Object::New(isolate)->GetPrototype(),
-			keys.data(),
-			values.data(),
-			column_count
-		);
-	}
-
-private:
-	v8::Isolate* isolate;
-	sqlite3_stmt* handle;
-	int column_count;
-	const bool safe_ints;
-	v8::LocalVector<v8::Name> keys;
-};
+class RowBuilder {
+public:
+
+	explicit RowBuilder(
+		v8::Isolate* isolate,
+		sqlite3_stmt* handle,
+		bool safe_ints
+	) :
+		isolate(isolate),
+		handle(handle),
+		column_count(-1),
+		safe_ints(safe_ints),
+		keys(isolate) {}
+
+	v8::Local<v8::Value> GetRowJS() {
+		if (column_count < 0) {
+			column_count = sqlite3_column_count(handle);
+			keys.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>()
+				);
+			}
+		}
+
+		v8::LocalVector<v8::Value> values(isolate);
+		values.reserve(column_count);
+		for (int i = 0; i < column_count; ++i) {
+			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
+		);
+	}
+
+private:
+	v8::Isolate* isolate;
+	sqlite3_stmt* handle;
+	int column_count;
+	const bool safe_ints;
+	v8::LocalVector<v8::Name> keys;
+};