better-sqlite3-multiple-ciphers 7.4.7-beta.0 → 7.5.1-beta.0

package/src/util/constants.lzz

@@ -1,151 +0,0 @@
-class CS {
-public:
-
-	v8::Local<v8::String> Code(v8::Isolate* isolate, int code) {
-		auto element = codes.find(code);
-		if (element != codes.end()) return element->second.Get(isolate);
-		return StringFromUtf8(isolate, (std::string("UNKNOWN_SQLITE_ERROR_") + std::to_string(code)).c_str(), -1);
-	}
-
-	explicit CS(v8::Isolate* isolate) {
-		SetString(isolate, database, "database");
-		SetString(isolate, reader, "reader");
-		SetString(isolate, source, "source");
-		SetString(isolate, memory, "memory");
-		SetString(isolate, readonly, "readonly");
-		SetString(isolate, name, "name");
-		SetString(isolate, next, "next");
-		SetString(isolate, length, "length");
-		SetString(isolate, done, "done");
-		SetString(isolate, value, "value");
-		SetString(isolate, changes, "changes");
-		SetString(isolate, lastInsertRowid, "lastInsertRowid");
-		SetString(isolate, statement, "statement");
-		SetString(isolate, column, "column");
-		SetString(isolate, table, "table");
-		SetString(isolate, type, "type");
-		SetString(isolate, totalPages, "totalPages");
-		SetString(isolate, remainingPages, "remainingPages");
-
-		SetCode(isolate, SQLITE_OK, "SQLITE_OK");
-		SetCode(isolate, SQLITE_ERROR, "SQLITE_ERROR");
-		SetCode(isolate, SQLITE_INTERNAL, "SQLITE_INTERNAL");
-		SetCode(isolate, SQLITE_PERM, "SQLITE_PERM");
-		SetCode(isolate, SQLITE_ABORT, "SQLITE_ABORT");
-		SetCode(isolate, SQLITE_BUSY, "SQLITE_BUSY");
-		SetCode(isolate, SQLITE_LOCKED, "SQLITE_LOCKED");
-		SetCode(isolate, SQLITE_NOMEM, "SQLITE_NOMEM");
-		SetCode(isolate, SQLITE_READONLY, "SQLITE_READONLY");
-		SetCode(isolate, SQLITE_INTERRUPT, "SQLITE_INTERRUPT");
-		SetCode(isolate, SQLITE_IOERR, "SQLITE_IOERR");
-		SetCode(isolate, SQLITE_CORRUPT, "SQLITE_CORRUPT");
-		SetCode(isolate, SQLITE_NOTFOUND, "SQLITE_NOTFOUND");
-		SetCode(isolate, SQLITE_FULL, "SQLITE_FULL");
-		SetCode(isolate, SQLITE_CANTOPEN, "SQLITE_CANTOPEN");
-		SetCode(isolate, SQLITE_PROTOCOL, "SQLITE_PROTOCOL");
-		SetCode(isolate, SQLITE_EMPTY, "SQLITE_EMPTY");
-		SetCode(isolate, SQLITE_SCHEMA, "SQLITE_SCHEMA");
-		SetCode(isolate, SQLITE_TOOBIG, "SQLITE_TOOBIG");
-		SetCode(isolate, SQLITE_CONSTRAINT, "SQLITE_CONSTRAINT");
-		SetCode(isolate, SQLITE_MISMATCH, "SQLITE_MISMATCH");
-		SetCode(isolate, SQLITE_MISUSE, "SQLITE_MISUSE");
-		SetCode(isolate, SQLITE_NOLFS, "SQLITE_NOLFS");
-		SetCode(isolate, SQLITE_AUTH, "SQLITE_AUTH");
-		SetCode(isolate, SQLITE_FORMAT, "SQLITE_FORMAT");
-		SetCode(isolate, SQLITE_RANGE, "SQLITE_RANGE");
-		SetCode(isolate, SQLITE_NOTADB, "SQLITE_NOTADB");
-		SetCode(isolate, SQLITE_NOTICE, "SQLITE_NOTICE");
-		SetCode(isolate, SQLITE_WARNING, "SQLITE_WARNING");
-		SetCode(isolate, SQLITE_ROW, "SQLITE_ROW");
-		SetCode(isolate, SQLITE_DONE, "SQLITE_DONE");
-		SetCode(isolate, SQLITE_IOERR_READ, "SQLITE_IOERR_READ");
-		SetCode(isolate, SQLITE_IOERR_SHORT_READ, "SQLITE_IOERR_SHORT_READ");
-		SetCode(isolate, SQLITE_IOERR_WRITE, "SQLITE_IOERR_WRITE");
-		SetCode(isolate, SQLITE_IOERR_FSYNC, "SQLITE_IOERR_FSYNC");
-		SetCode(isolate, SQLITE_IOERR_DIR_FSYNC, "SQLITE_IOERR_DIR_FSYNC");
-		SetCode(isolate, SQLITE_IOERR_TRUNCATE, "SQLITE_IOERR_TRUNCATE");
-		SetCode(isolate, SQLITE_IOERR_FSTAT, "SQLITE_IOERR_FSTAT");
-		SetCode(isolate, SQLITE_IOERR_UNLOCK, "SQLITE_IOERR_UNLOCK");
-		SetCode(isolate, SQLITE_IOERR_RDLOCK, "SQLITE_IOERR_RDLOCK");
-		SetCode(isolate, SQLITE_IOERR_DELETE, "SQLITE_IOERR_DELETE");
-		SetCode(isolate, SQLITE_IOERR_BLOCKED, "SQLITE_IOERR_BLOCKED");
-		SetCode(isolate, SQLITE_IOERR_NOMEM, "SQLITE_IOERR_NOMEM");
-		SetCode(isolate, SQLITE_IOERR_ACCESS, "SQLITE_IOERR_ACCESS");
-		SetCode(isolate, SQLITE_IOERR_CHECKRESERVEDLOCK, "SQLITE_IOERR_CHECKRESERVEDLOCK");
-		SetCode(isolate, SQLITE_IOERR_LOCK, "SQLITE_IOERR_LOCK");
-		SetCode(isolate, SQLITE_IOERR_CLOSE, "SQLITE_IOERR_CLOSE");
-		SetCode(isolate, SQLITE_IOERR_DIR_CLOSE, "SQLITE_IOERR_DIR_CLOSE");
-		SetCode(isolate, SQLITE_IOERR_SHMOPEN, "SQLITE_IOERR_SHMOPEN");
-		SetCode(isolate, SQLITE_IOERR_SHMSIZE, "SQLITE_IOERR_SHMSIZE");
-		SetCode(isolate, SQLITE_IOERR_SHMLOCK, "SQLITE_IOERR_SHMLOCK");
-		SetCode(isolate, SQLITE_IOERR_SHMMAP, "SQLITE_IOERR_SHMMAP");
-		SetCode(isolate, SQLITE_IOERR_SEEK, "SQLITE_IOERR_SEEK");
-		SetCode(isolate, SQLITE_IOERR_DELETE_NOENT, "SQLITE_IOERR_DELETE_NOENT");
-		SetCode(isolate, SQLITE_IOERR_MMAP, "SQLITE_IOERR_MMAP");
-		SetCode(isolate, SQLITE_IOERR_GETTEMPPATH, "SQLITE_IOERR_GETTEMPPATH");
-		SetCode(isolate, SQLITE_IOERR_CONVPATH, "SQLITE_IOERR_CONVPATH");
-		SetCode(isolate, SQLITE_IOERR_VNODE, "SQLITE_IOERR_VNODE");
-		SetCode(isolate, SQLITE_IOERR_AUTH, "SQLITE_IOERR_AUTH");
-		SetCode(isolate, SQLITE_LOCKED_SHAREDCACHE, "SQLITE_LOCKED_SHAREDCACHE");
-		SetCode(isolate, SQLITE_BUSY_RECOVERY, "SQLITE_BUSY_RECOVERY");
-		SetCode(isolate, SQLITE_BUSY_SNAPSHOT, "SQLITE_BUSY_SNAPSHOT");
-		SetCode(isolate, SQLITE_CANTOPEN_NOTEMPDIR, "SQLITE_CANTOPEN_NOTEMPDIR");
-		SetCode(isolate, SQLITE_CANTOPEN_ISDIR, "SQLITE_CANTOPEN_ISDIR");
-		SetCode(isolate, SQLITE_CANTOPEN_FULLPATH, "SQLITE_CANTOPEN_FULLPATH");
-		SetCode(isolate, SQLITE_CANTOPEN_CONVPATH, "SQLITE_CANTOPEN_CONVPATH");
-		SetCode(isolate, SQLITE_CORRUPT_VTAB, "SQLITE_CORRUPT_VTAB");
-		SetCode(isolate, SQLITE_READONLY_RECOVERY, "SQLITE_READONLY_RECOVERY");
-		SetCode(isolate, SQLITE_READONLY_CANTLOCK, "SQLITE_READONLY_CANTLOCK");
-		SetCode(isolate, SQLITE_READONLY_ROLLBACK, "SQLITE_READONLY_ROLLBACK");
-		SetCode(isolate, SQLITE_READONLY_DBMOVED, "SQLITE_READONLY_DBMOVED");
-		SetCode(isolate, SQLITE_ABORT_ROLLBACK, "SQLITE_ABORT_ROLLBACK");
-		SetCode(isolate, SQLITE_CONSTRAINT_CHECK, "SQLITE_CONSTRAINT_CHECK");
-		SetCode(isolate, SQLITE_CONSTRAINT_COMMITHOOK, "SQLITE_CONSTRAINT_COMMITHOOK");
-		SetCode(isolate, SQLITE_CONSTRAINT_FOREIGNKEY, "SQLITE_CONSTRAINT_FOREIGNKEY");
-		SetCode(isolate, SQLITE_CONSTRAINT_FUNCTION, "SQLITE_CONSTRAINT_FUNCTION");
-		SetCode(isolate, SQLITE_CONSTRAINT_NOTNULL, "SQLITE_CONSTRAINT_NOTNULL");
-		SetCode(isolate, SQLITE_CONSTRAINT_PRIMARYKEY, "SQLITE_CONSTRAINT_PRIMARYKEY");
-		SetCode(isolate, SQLITE_CONSTRAINT_TRIGGER, "SQLITE_CONSTRAINT_TRIGGER");
-		SetCode(isolate, SQLITE_CONSTRAINT_UNIQUE, "SQLITE_CONSTRAINT_UNIQUE");
-		SetCode(isolate, SQLITE_CONSTRAINT_VTAB, "SQLITE_CONSTRAINT_VTAB");
-		SetCode(isolate, SQLITE_CONSTRAINT_ROWID, "SQLITE_CONSTRAINT_ROWID");
-		SetCode(isolate, SQLITE_NOTICE_RECOVER_WAL, "SQLITE_NOTICE_RECOVER_WAL");
-		SetCode(isolate, SQLITE_NOTICE_RECOVER_ROLLBACK, "SQLITE_NOTICE_RECOVER_ROLLBACK");
-		SetCode(isolate, SQLITE_WARNING_AUTOINDEX, "SQLITE_WARNING_AUTOINDEX");
-		SetCode(isolate, SQLITE_AUTH_USER, "SQLITE_AUTH_USER");
-		SetCode(isolate, SQLITE_OK_LOAD_PERMANENTLY, "SQLITE_OK_LOAD_PERMANENTLY");
-	}
-
-	CopyablePersistent<v8::String> database;
-	CopyablePersistent<v8::String> reader;
-	CopyablePersistent<v8::String> source;
-	CopyablePersistent<v8::String> memory;
-	CopyablePersistent<v8::String> readonly;
-	CopyablePersistent<v8::String> name;
-	CopyablePersistent<v8::String> next;
-	CopyablePersistent<v8::String> length;
-	CopyablePersistent<v8::String> done;
-	CopyablePersistent<v8::String> value;
-	CopyablePersistent<v8::String> changes;
-	CopyablePersistent<v8::String> lastInsertRowid;
-	CopyablePersistent<v8::String> statement;
-	CopyablePersistent<v8::String> column;
-	CopyablePersistent<v8::String> table;
-	CopyablePersistent<v8::String> type;
-	CopyablePersistent<v8::String> totalPages;
-	CopyablePersistent<v8::String> remainingPages;
-
-private:
-
-	static void SetString(v8::Isolate* isolate, CopyablePersistent<v8::String>& constant, const char* str) {
-		constant.Reset(isolate, InternalizedFromLatin1(isolate, str));
-	}
-
-	void SetCode(v8::Isolate* isolate, int code, const char* str) {
-		codes.emplace(std::piecewise_construct,
-			std::forward_as_tuple(code),
-			std::forward_as_tuple(isolate, InternalizedFromLatin1(isolate, str)));
-	}
-
-	std::unordered_map<int, CopyablePersistent<v8::String> > codes;
-};

package/src/util/custom-aggregate.lzz

@@ -1,121 +0,0 @@
-class CustomAggregate : public CustomFunction {
-public:
-
-	explicit CustomAggregate(
-		v8::Isolate* isolate,
-		Database* db,
-		const char* name,
-		v8::Local<v8::Value> start,
-		v8::Local<v8::Function> step,
-		v8::Local<v8::Value> inverse,
-		v8::Local<v8::Value> result,
-		bool safe_ints
-	) :
-		CustomFunction(isolate, db, name, step, safe_ints),
-		invoke_result(result->IsFunction()),
-		invoke_start(start->IsFunction()),
-		inverse(isolate, inverse->IsFunction() ? inverse.As<v8::Function>() : v8::Local<v8::Function>()),
-		result(isolate, result->IsFunction() ? result.As<v8::Function>() : v8::Local<v8::Function>()),
-		start(isolate, start) {}
-
-	static void xStep(sqlite3_context* invocation, int argc, sqlite3_value** argv) {
-		xStepBase(invocation, argc, argv, &CustomAggregate::fn);
-	}
-
-	static void xInverse(sqlite3_context* invocation, int argc, sqlite3_value** argv) {
-		xStepBase(invocation, argc, argv, &CustomAggregate::inverse);
-	}
-
-	static void xValue(sqlite3_context* invocation) {
-		xValueBase(invocation, false);
-	}
-
-	static void xFinal(sqlite3_context* invocation) {
-		xValueBase(invocation, true);
-	}
-
-private:
-
-	static inline void xStepBase(sqlite3_context* invocation, int argc, sqlite3_value** argv, const CopyablePersistent<v8::Function> CustomAggregate::*ptrtm) {
-		AGGREGATE_START();
-
-		v8::Local<v8::Value> args_fast[5];
-		v8::Local<v8::Value>* args = argc <= 4 ? args_fast : ALLOC_ARRAY<v8::Local<v8::Value>>(argc + 1);
-		args[0] = acc->value.Get(isolate);
-		if (argc != 0) Data::GetArgumentsJS(isolate, args + 1, argv, argc, self->safe_ints);
-
-		v8::MaybeLocal<v8::Value> maybeReturnValue = (self->*ptrtm).Get(isolate)->Call(OnlyContext, v8::Undefined(isolate), argc + 1, args);
-		if (args != args_fast) delete[] args;
-
-		if (maybeReturnValue.IsEmpty()) {
-			self->PropagateJSError(invocation);
-		} else {
-			v8::Local<v8::Value> returnValue = maybeReturnValue.ToLocalChecked();
-			if (!returnValue->IsUndefined()) acc->value.Reset(isolate, returnValue);
-		}
-	}
-
-	static inline void xValueBase(sqlite3_context* invocation, bool is_final) {
-		AGGREGATE_START();
-
-		if (!is_final) {
-			acc->is_window = true;
-		} else if (acc->is_window) {
-			DestroyAccumulator(invocation);
-			return;
-		}
-
-		v8::Local<v8::Value> result = acc->value.Get(isolate);
-		if (self->invoke_result) {
-			v8::MaybeLocal<v8::Value> maybeResult = self->result.Get(isolate)->Call(OnlyContext, v8::Undefined(isolate), 1, &result);
-			if (maybeResult.IsEmpty()) {
-				self->PropagateJSError(invocation);
-				return;
-			}
-			result = maybeResult.ToLocalChecked();
-		}
-
-		Data::ResultValueFromJS(isolate, invocation, result, self);
-		if (is_final) DestroyAccumulator(invocation);
-	}
-
-	struct Accumulator { public:
-		CopyablePersistent<v8::Value> value;
-		bool initialized;
-		bool is_window;
-	}
-
-	Accumulator* GetAccumulator(sqlite3_context* invocation) {
-		Accumulator* acc = static_cast<Accumulator*>(sqlite3_aggregate_context(invocation, sizeof(Accumulator)));
-		if (!acc->initialized) {
-			assert(acc->value.IsEmpty());
-			acc->initialized = true;
-			if (invoke_start) {
-				v8::MaybeLocal<v8::Value> maybeSeed = start.Get(isolate).As<v8::Function>()->Call(OnlyContext, v8::Undefined(isolate), 0, NULL);
-				if (maybeSeed.IsEmpty()) PropagateJSError(invocation);
-				else acc->value.Reset(isolate, maybeSeed.ToLocalChecked());
-			} else {
-				assert(!start.IsEmpty());
-				acc->value.Reset(isolate, start);
-			}
-		}
-		return acc;
-	}
-
-	static void DestroyAccumulator(sqlite3_context* invocation) {
-		Accumulator* acc = static_cast<Accumulator*>(sqlite3_aggregate_context(invocation, sizeof(Accumulator)));
-		assert(acc->initialized);
-		acc->value.Reset();
-	}
-
-	void PropagateJSError(sqlite3_context* invocation) {
-		DestroyAccumulator(invocation);
-		CustomFunction::PropagateJSError(invocation);
-	}
-
-	const bool invoke_result;
-	const bool invoke_start;
-	const CopyablePersistent<v8::Function> inverse;
-	const CopyablePersistent<v8::Function> result;
-	const CopyablePersistent<v8::Value> start;
-};

package/src/util/custom-function.lzz

@@ -1,59 +0,0 @@
-class CustomFunction : protected DataConverter {
-public:
-
-	explicit CustomFunction(
-		v8::Isolate* isolate,
-		Database* db,
-		const char* name,
-		v8::Local<v8::Function> fn,
-		bool safe_ints
-	) :
-		name(name),
-		db(db),
-		isolate(isolate),
-		fn(isolate, fn),
-		safe_ints(safe_ints) {}
-
-	virtual ~CustomFunction() {}
-
-	static void xDestroy(void* self) {
-		delete static_cast<CustomFunction*>(self);
-	}
-
-	static void xFunc(sqlite3_context* invocation, int argc, sqlite3_value** argv) {
-		FUNCTION_START();
-
-		v8::Local<v8::Value> args_fast[4];
-		v8::Local<v8::Value>* args = NULL;
-		if (argc != 0) {
-			args = argc <= 4 ? args_fast : ALLOC_ARRAY<v8::Local<v8::Value>>(argc);
-			Data::GetArgumentsJS(isolate, args, argv, argc, self->safe_ints);
-		}
-
-		v8::MaybeLocal<v8::Value> maybeReturnValue = self->fn.Get(isolate)->Call(OnlyContext, v8::Undefined(isolate), argc, args);
-		if (args != args_fast) delete[] args;
-
-		if (maybeReturnValue.IsEmpty()) self->PropagateJSError(invocation);
-		else Data::ResultValueFromJS(isolate, invocation, maybeReturnValue.ToLocalChecked(), self);
-	}
-
-protected:
-
-	void PropagateJSError(sqlite3_context* invocation) {
-		assert(db->GetState()->was_js_error == false);
-		db->GetState()->was_js_error = true;
-		sqlite3_result_error(invocation, "", 0);
-	}
-
-	std::string GetDataErrorPrefix() {
-		return std::string("User-defined function ") + name + "() returned";
-	}
-
-private:
-	const std::string name;
-	Database* const db;
-protected:
-	v8::Isolate* const isolate;
-	const CopyablePersistent<v8::Function> fn;
-	const bool safe_ints;
-};