Print all the rows of the table test to the console
@@ -441,7 +455,7 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
};
/** Get the list of column names of a row of result of a statement.
- @return {string[]} The names of the columns
+ @return {Array} The names of the columns
@example
var stmt = db.prepare(
"SELECT 5 AS nbr, x'616200' AS data, NULL AS null_value;"
@@ -527,14 +541,13 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
pos = this.pos;
this.pos += 1;
}
- var bytes = intArrayFromString(string);
- var strptr = allocate(bytes, ALLOC_NORMAL);
+ var strptr = stringToNewUTF8(string);
this.allocatedmem.push(strptr);
this.db.handleError(sqlite3_bind_text(
this.stmt,
pos,
strptr,
- bytes.length - 1,
+ -1,
0
));
return true;
@@ -545,7 +558,8 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
pos = this.pos;
this.pos += 1;
}
- var blobptr = allocate(array, ALLOC_NORMAL);
+ var blobptr = _malloc(array.length);
+ writeArrayToMemory(array, blobptr);
this.allocatedmem.push(blobptr);
this.db.handleError(sqlite3_bind_blob(
this.stmt,
@@ -630,7 +644,7 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
};
/** Bind values to numbered parameters
- @param {Database.SqlValue[]} values
+ @param {Array} values
@private
@nodoc
*/
@@ -641,7 +655,7 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
return true;
};
- /** Reset a statement, so that it's parameters can be bound to new values
+ /** Reset a statement, so that its parameters can be bound to new values
It also clears all previous bindings, freeing the memory used
by bound parameters.
*/
@@ -716,12 +730,10 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
*/
function StatementIterator(sql, db) {
this.db = db;
- var sz = lengthBytesUTF8(sql) + 1;
- this.sqlPtr = _malloc(sz);
+ this.sqlPtr = stringToNewUTF8(sql);
if (this.sqlPtr === null) {
throw new Error("Unable to allocate memory for the SQL string");
}
- stringToUTF8(sql, this.sqlPtr, sz);
this.nextSqlPtr = this.sqlPtr;
this.nextSqlString = null;
this.activeStatement = null;
@@ -811,7 +823,7 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
* @memberof module:SqlJs
* Open a new database either by creating a new one or opening an existing
* one stored in the byte array passed in first argument
- * @param {number[]} data An array of bytes representing
+ * @param {Array} data An array of bytes representing
* an SQLite database file
*/
function Database(data) {
@@ -864,12 +876,14 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
/**
* @typedef {{
- columns:string[],
- values:Database.SqlValue[][]
+ columns:Array,
+ values:Array>
}} Database.QueryExecResult
- * @property {string[]} columns the name of the columns of the result
+ * @property {Array} columns the name of the columns of the result
* (as returned by {@link Statement.getColumnNames})
- * @property {Database.SqlValue[][]} values one array per row, containing
+ * @property {
+ * Array>
+ * } values one array per row, containing
* the column values
*/
@@ -926,31 +940,33 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
before it is executed. If you use the params argument as an array,
you **cannot** provide an sql string that contains several statements
(separated by `;`). This limitation does not apply to params as an object.
- * @return {Database.QueryExecResult[]} The results of each statement
+ * @return {Array} The results of each statement
*/
Database.prototype["exec"] = function exec(sql, params, config) {
if (!this.db) {
throw "Database closed";
}
- var stack = stackSave();
var stmt = null;
+ var originalSqlPtr = null;
+ var currentSqlPtr = null;
try {
- var nextSqlPtr = allocateUTF8OnStack(sql);
+ originalSqlPtr = stringToNewUTF8(sql);
+ currentSqlPtr = originalSqlPtr;
var pzTail = stackAlloc(4);
var results = [];
- while (getValue(nextSqlPtr, "i8") !== NULL) {
+ while (getValue(currentSqlPtr, "i8") !== NULL) {
setValue(apiTemp, 0, "i32");
setValue(pzTail, 0, "i32");
this.handleError(sqlite3_prepare_v2_sqlptr(
this.db,
- nextSqlPtr,
+ currentSqlPtr,
-1,
apiTemp,
pzTail
));
// pointer to a statement, or null
var pStmt = getValue(apiTemp, "i32");
- nextSqlPtr = getValue(pzTail, "i32");
+ currentSqlPtr = getValue(pzTail, "i32");
// Empty statement
if (pStmt !== NULL) {
var curresult = null;
@@ -976,7 +992,7 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
if (stmt) stmt["free"]();
throw errCaught;
} finally {
- stackRestore(stack);
+ if (originalSqlPtr) _free(originalSqlPtr);
}
};
@@ -987,7 +1003,7 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
@param {string} sql A string of SQL text. Can contain placeholders
that will be bound to the parameters given as the second argument
- @param {Statement.BindParams} [params=[]] Parameters to bind to the query
+ @param {Statement.BindParams=} [params=] Parameters to bind to the query
@param {function(Object):void} callback
Function to call on each row of result
@param {function():void} done A function that will be called when
@@ -1000,9 +1016,8 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
function (row){console.log(row.name + " is a grown-up.")}
);
*/
- Database.prototype["each"] = function each(
- sql, params, callback, done, config
- ) {
+ // eslint-disable-next-line max-len
+ Database.prototype["each"] = function each(sql, params, callback, done, config) {
var stmt;
if (typeof params === "function") {
done = callback;
@@ -1066,7 +1081,9 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
return new StatementIterator(sql, this);
};
- /** Exports the contents of the database to a binary array
+ /** Exports the contents of the database to a binary array. This
+ * operation will close and re-open the database which will cause
+ * any pragmas to be set back to their default values.
@return {Uint8Array} An array of bytes of the SQLite3 database file
*/
Database.prototype["export"] = function exportDatabase() {
@@ -1079,6 +1096,7 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
var binaryDb = FS.readFile(this.filename, { encoding: "binary" });
this.handleError(sqlite3_open(this.filename, apiTemp));
this.db = getValue(apiTemp, "i32");
+ registerExtensionFunctions(this.db);
return binaryDb;
};
@@ -1102,6 +1120,12 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
});
Object.values(this.functions).forEach(removeFunction);
this.functions = {};
+
+ if (this.updateHookFunctionPtr) {
+ removeFunction(this.updateHookFunctionPtr);
+ this.updateHookFunctionPtr = undefined;
+ }
+
this.handleError(sqlite3_close_v2(this.db));
FS.unlink("/" + this.filename);
this.db = null;
@@ -1131,81 +1155,93 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
return sqlite3_changes(this.db);
};
- /** Register a custom function with SQLite
- @example Register a simple function
- db.create_function("addOne", function (x) {return x+1;})
- db.exec("SELECT addOne(1)") // = 2
+ var extract_blob = function extract_blob(ptr) {
+ var size = sqlite3_value_bytes(ptr);
+ var blob_ptr = sqlite3_value_blob(ptr);
+ var blob_arg = new Uint8Array(size);
+ for (var j = 0; j < size; j += 1) {
+ blob_arg[j] = HEAP8[blob_ptr + j];
+ }
+ return blob_arg;
+ };
- @param {string} name the name of the function as referenced in
- SQL statements.
- @param {function} func the actual function to be executed.
- @return {Database} The database object. Useful for method chaining
- */
+ var parseFunctionArguments = function parseFunctionArguments(argc, argv) {
+ var args = [];
+ for (var i = 0; i < argc; i += 1) {
+ var value_ptr = getValue(argv + (4 * i), "i32");
+ var value_type = sqlite3_value_type(value_ptr);
+ var arg;
+ if (
+ value_type === SQLITE_INTEGER
+ || value_type === SQLITE_FLOAT
+ ) {
+ arg = sqlite3_value_double(value_ptr);
+ } else if (value_type === SQLITE_TEXT) {
+ arg = sqlite3_value_text(value_ptr);
+ } else if (value_type === SQLITE_BLOB) {
+ arg = extract_blob(value_ptr);
+ } else arg = null;
+ args.push(arg);
+ }
+ return args;
+ };
+ var setFunctionResult = function setFunctionResult(cx, result) {
+ switch (typeof result) {
+ case "boolean":
+ sqlite3_result_int(cx, result ? 1 : 0);
+ break;
+ case "number":
+ sqlite3_result_double(cx, result);
+ break;
+ case "string":
+ sqlite3_result_text(cx, result, -1, -1);
+ break;
+ case "object":
+ if (result === null) {
+ sqlite3_result_null(cx);
+ } else if (result.length != null) {
+ var blobptr = _malloc(result.length);
+ writeArrayToMemory(result, blobptr);
+ sqlite3_result_blob(cx, blobptr, result.length, -1);
+ _free(blobptr);
+ } else {
+ sqlite3_result_error(
+ cx, (
+ "Wrong API use : tried to return a value "
+ + "of an unknown type (" + result + ")."
+ ), -1
+ );
+ }
+ break;
+ default:
+ sqlite3_result_null(cx);
+ }
+ };
+
+ /** Register a custom function with SQLite
+ @example
Register a simple function
+ db.create_function("addOne", function (x) {return x+1;})
+ db.exec("SELECT addOne(1)") // = 2
+
+ @param {string} name the name of the function as referenced in
+ SQL statements.
+ @param {function(any)} func the actual function to be executed.
+ @return {Database} The database object. Useful for method chaining
+ */
Database.prototype["create_function"] = function create_function(
name,
func
) {
function wrapped_func(cx, argc, argv) {
+ var args = parseFunctionArguments(argc, argv);
var result;
- function extract_blob(ptr) {
- var size = sqlite3_value_bytes(ptr);
- var blob_ptr = sqlite3_value_blob(ptr);
- var blob_arg = new Uint8Array(size);
- for (var j = 0; j < size; j += 1) {
- blob_arg[j] = HEAP8[blob_ptr + j];
- }
- return blob_arg;
- }
- var args = [];
- for (var i = 0; i < argc; i += 1) {
- var value_ptr = getValue(argv + (4 * i), "i32");
- var value_type = sqlite3_value_type(value_ptr);
- var arg;
- if (
- value_type === SQLITE_INTEGER
- || value_type === SQLITE_FLOAT
- ) {
- arg = sqlite3_value_double(value_ptr);
- } else if (value_type === SQLITE_TEXT) {
- arg = sqlite3_value_text(value_ptr);
- } else if (value_type === SQLITE_BLOB) {
- arg = extract_blob(value_ptr);
- } else arg = null;
- args.push(arg);
- }
try {
result = func.apply(null, args);
} catch (error) {
sqlite3_result_error(cx, error, -1);
return;
}
- switch (typeof result) {
- case "boolean":
- sqlite3_result_int(cx, result ? 1 : 0);
- break;
- case "number":
- sqlite3_result_double(cx, result);
- break;
- case "string":
- sqlite3_result_text(cx, result, -1, -1);
- break;
- case "object":
- if (result === null) {
- sqlite3_result_null(cx);
- } else if (result.length != null) {
- var blobptr = allocate(result, ALLOC_NORMAL);
- sqlite3_result_blob(cx, blobptr, result.length, -1);
- _free(blobptr);
- } else {
- sqlite3_result_error(cx, (
- "Wrong API use : tried to return a value "
- + "of an unknown type (" + result + ")."
- ), -1);
- }
- break;
- default:
- sqlite3_result_null(cx);
- }
+ setFunctionResult(cx, result);
}
if (Object.prototype.hasOwnProperty.call(this.functions, name)) {
removeFunction(this.functions[name]);
@@ -1229,6 +1265,274 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
return this;
};
+ /** Register a custom aggregate with SQLite
+ @example
Register a custom sum function
+ db.create_aggregate("js_sum", {
+ init: () => 0,
+ step: (state, value) => state + value,
+ finalize: state => state
+ });
+ db.exec("SELECT js_sum(column1) FROM (VALUES (1), (2))"); // = 3
+
+ @param {string} name the name of the aggregate as referenced in
+ SQL statements.
+ @param {object} aggregateFunctions
+ object containing at least a step function.
+ @param {function(): T} [aggregateFunctions.init=]
+ a function receiving no arguments and returning an initial
+ value for the aggregate function. The initial value will be
+ null if this key is omitted.
+ @param {function(T, any) : T} aggregateFunctions.step
+ a function receiving the current state and a value to aggregate
+ and returning a new state.
+ Will receive the value from init for the first step.
+ @param {function(T): any} [aggregateFunctions.finalize=]
+ a function returning the result of the aggregate function
+ given its final state.
+ If omitted, the value returned by the last step
+ will be used as the final value.
+ @return {Database} The database object. Useful for method chaining
+ @template T
+ */
+ Database.prototype["create_aggregate"] = function create_aggregate(
+ name,
+ aggregateFunctions
+ ) {
+ // Default initializer and finalizer
+ var init = aggregateFunctions["init"]
+ || function init() { return null; };
+ var finalize = aggregateFunctions["finalize"]
+ || function finalize(state) { return state; };
+ var step = aggregateFunctions["step"];
+
+ if (!step) {
+ throw "An aggregate function must have a step function in " + name;
+ }
+
+ // state is a state object; we'll use the pointer p to serve as the
+ // key for where we hold our state so that multiple invocations of
+ // this function never step on each other
+ var state = {};
+
+ function wrapped_step(cx, argc, argv) {
+ // > The first time the sqlite3_aggregate_context(C,N) routine is
+ // > called for a particular aggregate function, SQLite allocates N
+ // > bytes of memory, zeroes out that memory, and returns a pointer
+ // > to the new memory.
+ //
+ // We're going to use that pointer as a key to our state array,
+ // since using sqlite3_aggregate_context as it's meant to be used
+ // through webassembly seems to be very difficult. Just allocate
+ // one byte.
+ var p = sqlite3_aggregate_context(cx, 1);
+
+ // If this is the first invocation of wrapped_step, call `init`
+ //
+ // Make sure that every path through the step and finalize
+ // functions deletes the value state[p] when it's done so we don't
+ // leak memory and possibly stomp the init value of future calls
+ if (!Object.hasOwnProperty.call(state, p)) state[p] = init();
+
+ var args = parseFunctionArguments(argc, argv);
+ var mergedArgs = [state[p]].concat(args);
+ try {
+ state[p] = step.apply(null, mergedArgs);
+ } catch (error) {
+ delete state[p];
+ sqlite3_result_error(cx, error, -1);
+ }
+ }
+
+ function wrapped_finalize(cx) {
+ var result;
+ var p = sqlite3_aggregate_context(cx, 1);
+ try {
+ result = finalize(state[p]);
+ } catch (error) {
+ delete state[p];
+ sqlite3_result_error(cx, error, -1);
+ return;
+ }
+ setFunctionResult(cx, result);
+ delete state[p];
+ }
+
+ if (Object.hasOwnProperty.call(this.functions, name)) {
+ removeFunction(this.functions[name]);
+ delete this.functions[name];
+ }
+ var finalize_name = name + "__finalize";
+ if (Object.hasOwnProperty.call(this.functions, finalize_name)) {
+ removeFunction(this.functions[finalize_name]);
+ delete this.functions[finalize_name];
+ }
+ // The signature of the wrapped function is :
+ // void wrapped(sqlite3_context *db, int argc, sqlite3_value **argv)
+ var step_ptr = addFunction(wrapped_step, "viii");
+
+ // The signature of the wrapped function is :
+ // void wrapped(sqlite3_context *db)
+ var finalize_ptr = addFunction(wrapped_finalize, "vi");
+ this.functions[name] = step_ptr;
+ this.functions[finalize_name] = finalize_ptr;
+
+ // passing null to the sixth parameter defines this as an aggregate
+ // function
+ //
+ // > An aggregate SQL function requires an implementation of xStep and
+ // > xFinal and NULL pointer must be passed for xFunc.
+ // - http://www.sqlite.org/c3ref/create_function.html
+ this.handleError(sqlite3_create_function_v2(
+ this.db,
+ name,
+ step.length - 1,
+ SQLITE_UTF8,
+ 0,
+ 0,
+ step_ptr,
+ finalize_ptr,
+ 0
+ ));
+ return this;
+ };
+
+ /** Registers an update hook with SQLite.
+ *
+ * Every time a row is changed by whatever means, the callback is called
+ * once with the change (`'insert'`, `'update'` or `'delete'`), the database
+ * name and table name where the change happened and the
+ * [rowid](https://www.sqlite.org/rowidtable.html)
+ * of the row that has been changed.
+ *
+ * The rowid is cast to a plain number. If it exceeds
+ * `Number.MAX_SAFE_INTEGER` (2^53 - 1), an error will be thrown.
+ *
+ * **Important notes:**
+ * - The callback **MUST NOT** modify the database in any way
+ * - Only a single callback can be registered at a time
+ * - Unregister the callback by passing `null`
+ * - Not called for some updates like `ON REPLACE CONFLICT` and `TRUNCATE`
+ * (a `DELETE FROM` without a `WHERE` clause)
+ *
+ * See SQLite documentation on
+ * [sqlite3_update_hook](https://www.sqlite.org/c3ref/update_hook.html)
+ * for more details
+ *
+ * @example
+ * // Create a database and table
+ * var db = new SQL.Database();
+ * db.exec(`
+ * CREATE TABLE users (
+ * id INTEGER PRIMARY KEY, -- this is the rowid column
+ * name TEXT,
+ * active INTEGER
+ * )
+ * `);
+ *
+ * // Register an update hook
+ * var changes = [];
+ * db.updateHook(function(operation, database, table, rowId) {
+ * changes.push({operation, database, table, rowId});
+ * console.log(`${operation} on ${database}.${table} row ${rowId}`);
+ * });
+ *
+ * // Insert a row - triggers the update hook with 'insert'
+ * db.run("INSERT INTO users VALUES (1, 'Alice', 1)");
+ * // Logs: "insert on main.users row 1"
+ *
+ * // Update a row - triggers the update hook with 'update'
+ * db.run("UPDATE users SET active = 0 WHERE id = 1");
+ * // Logs: "update on main.users row 1"
+ *
+ * // Delete a row - triggers the update hook with 'delete'
+ * db.run("DELETE FROM users WHERE id = 1");
+ * // Logs: "delete on main.users row 1"
+ *
+ * // Unregister the update hook
+ * db.updateHook(null);
+ *
+ * // This won't trigger any callback
+ * db.run("INSERT INTO users VALUES (2, 'Bob', 1)");
+ *
+ * @param {Database~UpdateHookCallback|null} callback
+ * - Callback to be executed when a row changes. Takes the type of change,
+ * the name of the database, the name of the table, and the row id of the
+ * changed row.
+ * - Set to `null` to unregister.
+ * @returns {Database} The database object. Useful for method chaining
+ */
+ Database.prototype["updateHook"] = function updateHook(callback) {
+ if (this.updateHookFunctionPtr) {
+ // unregister and cleanup a previously registered update hook
+ sqlite3_update_hook(this.db, 0, 0);
+ removeFunction(this.updateHookFunctionPtr);
+ this.updateHookFunctionPtr = undefined;
+ }
+
+ if (!callback) {
+ // no new callback to register
+ return this;
+ }
+
+ // void(*)(void *,int ,char const *,char const *,sqlite3_int64)
+ function wrappedCallback(
+ ignored,
+ operationCode,
+ databaseNamePtr,
+ tableNamePtr,
+ rowIdBigInt
+ ) {
+ var operation;
+
+ switch (operationCode) {
+ case SQLITE_INSERT:
+ operation = "insert";
+ break;
+ case SQLITE_UPDATE:
+ operation = "update";
+ break;
+ case SQLITE_DELETE:
+ operation = "delete";
+ break;
+ default:
+ throw "unknown operationCode in updateHook callback: "
+ + operationCode;
+ }
+
+ var databaseName = UTF8ToString(databaseNamePtr);
+ var tableName = UTF8ToString(tableNamePtr);
+
+ if (rowIdBigInt > Number.MAX_SAFE_INTEGER) {
+ throw "rowId too big to fit inside a Number";
+ }
+
+ var rowId = Number(rowIdBigInt);
+
+ callback(operation, databaseName, tableName, rowId);
+ }
+
+ this.updateHookFunctionPtr = addFunction(wrappedCallback, "viiiij");
+
+ sqlite3_update_hook(
+ this.db,
+ this.updateHookFunctionPtr,
+ 0 // passed as the first arg to wrappedCallback
+ );
+ return this;
+ };
+
+ /**
+ * @callback Database~UpdateHookCallback
+ * @param {'insert'|'update'|'delete'} operation
+ * - The type of change that occurred
+ * @param {string} database
+ * - The name of the database where the change occurred
+ * @param {string} table
+ * - The name of the database's table where the change occurred
+ * @param {number} rowId
+ * - The [rowid](https://www.sqlite.org/rowidtable.html) of the changed row
+ */
+
// export Database to Module
Module.Database = Database;
};
diff --git a/src/exported_functions.json b/src/exported_functions.json
index b93b07d2..3be25955 100644
--- a/src/exported_functions.json
+++ b/src/exported_functions.json
@@ -41,5 +41,7 @@
"_sqlite3_result_int",
"_sqlite3_result_int64",
"_sqlite3_result_error",
-"_RegisterExtensionFunctions"
+"_sqlite3_aggregate_context",
+"_RegisterExtensionFunctions",
+"_sqlite3_update_hook"
]
diff --git a/src/exported_runtime_methods.json b/src/exported_runtime_methods.json
index 13a8efb8..f099056f 100644
--- a/src/exported_runtime_methods.json
+++ b/src/exported_runtime_methods.json
@@ -3,5 +3,9 @@
"stackAlloc",
"stackSave",
"stackRestore",
-"UTF8ToString"
+"UTF8ToString",
+"stringToNewUTF8",
+"writeArrayToMemory",
+"removeFunction",
+"addFunction"
]
diff --git a/src/worker.js b/src/worker.js
index f75bf6a1..10c6f3c1 100644
--- a/src/worker.js
+++ b/src/worker.js
@@ -35,6 +35,11 @@ function onModuleReady(SQL) {
id: data["id"],
results: db.exec(data["sql"], data["params"], config)
});
+ case "getRowsModified":
+ return postMessage({
+ id: data["id"],
+ rowsModified: db.getRowsModified()
+ });
case "each":
if (db === null) {
createDb();
@@ -83,12 +88,36 @@ function onError(err) {
});
}
+db = null;
+var sqlModuleReady = initSqlJs();
+
+function global_sqljs_message_handler(event) {
+ return sqlModuleReady
+ .then(onModuleReady.bind(event))
+ .catch(onError.bind(event));
+}
+
if (typeof importScripts === "function") {
- db = null;
- var sqlModuleReady = initSqlJs();
- self.onmessage = function onmessage(event) {
- return sqlModuleReady
- .then(onModuleReady.bind(event))
- .catch(onError.bind(event));
- };
+ self.onmessage = global_sqljs_message_handler;
+}
+
+if (typeof require === "function") {
+ // eslint-disable-next-line global-require
+ var worker_threads = require("worker_threads");
+ var parentPort = worker_threads.parentPort;
+ // eslint-disable-next-line no-undef
+ globalThis.postMessage = parentPort.postMessage.bind(parentPort);
+ parentPort.on("message", function onmessage(data) {
+ var event = { data: data };
+ global_sqljs_message_handler(event);
+ });
+
+ if (typeof process !== "undefined") {
+ process.on("uncaughtException", function uncaughtException(err) {
+ postMessage({ error: err.message });
+ });
+ process.on("unhandledRejection", function unhandledRejection(err) {
+ postMessage({ error: err.message });
+ });
+ }
}
diff --git a/test/test_aggregate_functions.js b/test/test_aggregate_functions.js
new file mode 100644
index 00000000..d28c775f
--- /dev/null
+++ b/test/test_aggregate_functions.js
@@ -0,0 +1,132 @@
+exports.test = function (SQL, assert) {
+ function assertFloat(got, expected, message="", sigma=0.001) {
+ assert.ok(got > expected - sigma && got < expected + sigma, message);
+ }
+
+ var db = new SQL.Database();
+
+ db.create_aggregate("sum", {
+ step: function (state, value) { return (state || 0) + value; },
+ });
+
+ db.exec("CREATE TABLE test (col);");
+ db.exec("INSERT INTO test VALUES (1), (2), (3), (null);");
+ var result = db.exec("SELECT sum(col) FROM test;");
+ assert.equal(result[0].values[0][0], 6, "Simple aggregate function.");
+
+ db.create_aggregate("percentile", {
+ init: function() { return { vals: [], pctile: null }},
+ step: function (state, value, pctile) {
+ var typ = typeof value;
+ if (typ == "number" || typ == "bigint") { // ignore nulls
+ state.pctile = pctile;
+ state.vals.push(value);
+ }
+ return state;
+ },
+ finalize: function (state) {
+ return percentile(state.vals, state.pctile);
+ }
+ });
+ result = db.exec("SELECT percentile(col, 80) FROM test;");
+ assertFloat(result[0].values[0][0], 2.6, "Aggregate function with two args");
+
+ db.create_aggregate("json_agg", {
+ init: () => [],
+ step: (state, val) => [...state, val],
+ finalize: (state) => JSON.stringify(state),
+ });
+
+ db.exec("CREATE TABLE test2 (col, col2);");
+ db.exec("INSERT INTO test2 values ('four score', 12), ('and seven', 7), ('years ago', 1);");
+ result = db.exec("SELECT json_agg(col) FROM test2;");
+ assert.deepEqual(
+ JSON.parse(result[0].values[0]),
+ ["four score", "and seven", "years ago"],
+ "Aggregate function that returns JSON"
+ );
+
+ result = db.exec("SELECT json_agg(col), json_agg(col2) FROM test2;");
+ assert.deepEqual(
+ result[0].values[0].map(JSON.parse),
+ [["four score", "and seven", "years ago"], [12, 7, 1]],
+ "Multiple aggregations at once"
+ );
+
+ db.create_aggregate("is_even", {
+ init: () => true,
+ step: state => !state
+ });
+ result = db.exec("SELECT is_even() FROM (VALUES (1),(2),(0));");
+ assert.deepEqual(
+ result[0].values[0][0],
+ 0, // this gets convert from "false" to an int by sqlite
+ "Aggregate functions respect falsy values"
+ );
+
+ db.create_aggregate("sum_non_zero", {
+ init: () => 0,
+ step: (state, value) => {
+ if (!value) throw "bananas";
+ return state + value
+ }
+ });
+ assert.throws(
+ () => db.exec("SELECT sum_non_zero(column1) FROM (VALUES (1),(2),(0));"),
+ "Error: bananas",
+ "Handles exception in a step function"
+ );
+ assert.deepEqual(
+ db.exec("SELECT sum_non_zero(column1) FROM (VALUES (1),(2));")[0].values[0][0],
+ 3,
+ "Aggregate functions work after an exception has been thrown in step"
+ );
+
+ db.create_aggregate("throws_finalize", {
+ step: (state, value) => (state || 0) + value,
+ finalize: (state) => {
+ if (!state) throw "shoes"
+ return state;
+ }
+ });
+ assert.throws(
+ () => db.exec("SELECT throws_finalize(column1) FROM (VALUES (0));"),
+ "Error: shoes",
+ "Handles exception in a finalize function"
+ );
+ assert.deepEqual(
+ db.exec("SELECT throws_finalize(column1) FROM (VALUES (1),(2));")[0].values[0][0],
+ 3,
+ "Aggregate functions work after an exception has been thrown in finalize"
+ );
+}
+
+// helper function to calculate a percentile from an array. Will modify the
+// array in-place.
+function percentile(arr, p) {
+ arr.sort();
+ const pos = (arr.length - 1) * (p / 100);
+ const base = Math.floor(pos);
+ const rest = pos - base;
+ if (arr[base + 1] !== undefined) {
+ return arr[base] + rest * (arr[base + 1] - arr[base]);
+ } else {
+ return arr[base];
+ }
+};
+
+if (module == require.main) {
+ const target_file = process.argv[2];
+ const sql_loader = require('./load_sql_lib');
+ sql_loader(target_file).then((sql)=>{
+ require('test').run({
+ 'test functions': function(assert, done){
+ exports.test(sql, assert, done);
+ }
+ });
+ })
+ .catch((e)=>{
+ console.error(e);
+ assert.fail(e);
+ });
+}
diff --git a/test/test_aggregate_redefinition.js b/test/test_aggregate_redefinition.js
new file mode 100644
index 00000000..05779720
--- /dev/null
+++ b/test/test_aggregate_redefinition.js
@@ -0,0 +1,80 @@
+exports.test = function(sql, assert) {
+ // Test 1: Create a database, Register single function, close database, repeat 1000 times
+ for (var i = 1; i <= 1000; i++)
+ {
+ let lastStep = i == 1000;
+ let db = new sql.Database();
+ try {
+ db.create_aggregate("TestFunction"+i, {step: (state, value) => i})
+ } catch(e) {
+ assert.ok(
+ false,
+ "Test 1: Recreate database "+i+"th times and register aggregate"
+ +" function failed with exception:"+e
+ );
+ db.close();
+ break;
+ }
+ var result = db.exec("SELECT TestFunction"+i+"(1)");
+ var result_str = result[0]["values"][0][0];
+ if(result_str != i || lastStep)
+ {
+ assert.equal(
+ result_str,
+ i,
+ "Test 1: Recreate database "+i+"th times and register aggregate function"
+ );
+ db.close();
+ break;
+ }
+ db.close();
+ }
+
+ // Test 2: Create a database, Register same function 1000 times, close database
+ {
+ let db = new sql.Database();
+ for (var i = 1; i <= 1000; i++)
+ {
+ let lastStep = i == 1000;
+ try {
+ db.create_aggregate("TestFunction", {step: (state, value) => i})
+ } catch(e) {
+ assert.ok(
+ false,
+ "Test 2: Reregister aggregate function "+i+"th times failed with"
+ +" exception:"+e
+ );
+ break;
+ }
+ var result = db.exec("SELECT TestFunction(1)");
+ var result_str = result[0]["values"][0][0];
+ if(result_str != i || lastStep)
+ {
+ assert.equal(
+ result_str,
+ i,
+ "Test 2: Reregister function "+i+"th times"
+ );
+ break;
+ }
+ }
+ db.close();
+ }
+};
+
+
+if (module == require.main) {
+ const target_file = process.argv[2];
+ const sql_loader = require('./load_sql_lib');
+ sql_loader(target_file).then((sql)=>{
+ require('test').run({
+ 'test creating multiple functions': function(assert){
+ exports.test(sql, assert);
+ }
+ });
+ })
+ .catch((e)=>{
+ console.error(e);
+ assert.fail(e);
+ });
+}
diff --git a/test/test_extension_functions.js b/test/test_extension_functions.js
index d9542ac0..0a8d6d17 100644
--- a/test/test_extension_functions.js
+++ b/test/test_extension_functions.js
@@ -69,6 +69,9 @@ exports.test = function(sql, assert) {
var res = db.exec("SELECT reverse(str_data) FROM test;");
assert.equal(res[0]['values'][0][0], "!dlroW olleH", "reverse() function works");
+ db.export()
+ var res = db.exec("SELECT floor(4.1)");
+ assert.equal(res[0]['values'][0][0], 4, "extension function works after export()");
};
if (module == require.main) {
diff --git a/test/test_long_sql_statement.js b/test/test_long_sql_statement.js
new file mode 100644
index 00000000..7c805566
--- /dev/null
+++ b/test/test_long_sql_statement.js
@@ -0,0 +1,36 @@
+// test for https://github.com/sql-js/sql.js/issues/561
+exports.test = function (sql, assert) {
+ // Create a database
+ var db = new sql.Database();
+ var len = 1000000;
+ var many_a = "";
+ for (var a = 'a'; many_a.length < len; a += a)
+ if ((len / a.length) & 1)
+ many_a += a;
+
+ var res = db.exec("select length('" + many_a + "') as len");
+ var expectedResult = [
+ {
+ columns: ['len'],
+ values: [
+ [len]
+ ]
+ }
+ ];
+ assert.deepEqual(res, expectedResult, "length of long string");
+};
+
+if (module == require.main) {
+ const target_file = process.argv[2];
+ const sql_loader = require('./load_sql_lib');
+ sql_loader(target_file).then((sql) => {
+ require('test').run({
+ 'test long sql string (issue 561)': function (assert) {
+ exports.test(sql, assert);
+ }
+ });
+ }).catch((e) => {
+ console.error(e);
+ assert.fail(e);
+ });
+}
diff --git a/test/test_update_hook.js b/test/test_update_hook.js
new file mode 100644
index 00000000..ec875e25
--- /dev/null
+++ b/test/test_update_hook.js
@@ -0,0 +1,72 @@
+exports.test = function(SQL, assert){
+ var db = new SQL.Database();
+
+ db.exec(
+ "CREATE TABLE consoles (id INTEGER PRIMARY KEY, company TEXT, name TEXT);" +
+ "INSERT INTO consoles VALUES (1, 'Sony', 'Playstation');" +
+ "INSERT INTO consoles VALUES (2, 'Microsoft', 'Xbox');"
+ );
+
+ // {operation: undefined, databaseName: undefined, tableName: undefined, rowId: undefined};
+ var updateHookCalls = []
+
+ db.updateHook(function(operation, databaseName, tableName, rowId) {
+ updateHookCalls.push({operation, databaseName, tableName, rowId});
+ });
+
+ // INSERT
+ db.exec("INSERT INTO consoles VALUES (3, 'Sega', 'Saturn');");
+
+ assert.deepEqual(updateHookCalls, [
+ {operation: "insert", databaseName: "main", tableName: "consoles", rowId: 3}
+ ], "insert a single row");
+
+ // UPDATE
+ updateHookCalls = []
+ db.exec("UPDATE consoles SET name = 'Playstation 5' WHERE id = 1");
+
+ assert.deepEqual(updateHookCalls, [
+ {operation: "update", databaseName: "main", tableName: "consoles", rowId: 1}
+ ], "update a single row");
+
+ // UPDATE (multiple rows)
+ updateHookCalls = []
+ db.exec("UPDATE consoles SET name = name + ' [legacy]' WHERE id IN (2,3)");
+
+ assert.deepEqual(updateHookCalls, [
+ {operation: "update", databaseName: "main", tableName: "consoles", rowId: 2},
+ {operation: "update", databaseName: "main", tableName: "consoles", rowId: 3},
+ ], "update two rows");
+
+ // DELETE
+ updateHookCalls = []
+ db.exec("DELETE FROM consoles WHERE company = 'Sega'");
+
+ assert.deepEqual(updateHookCalls, [
+ {operation: "delete", databaseName: "main", tableName: "consoles", rowId: 3}
+ ], "delete a single row");
+
+ // UNREGISTER
+ updateHookCalls = []
+
+ db.updateHook(null);
+
+ db.exec("DELETE FROM consoles WHERE company = 'Microsoft'");
+
+ assert.deepEqual(updateHookCalls, [], "unregister the update hook");
+
+ // REGISTER AGAIN
+ updateHookCalls = []
+
+ db.updateHook(function(operation, databaseName, tableName, rowId) {
+ updateHookCalls.push({operation, databaseName, tableName, rowId});
+ });
+
+ // need a where clause, just running "DELETE FROM consoles" would result in
+ // a TRUNCATE and not yield any update hook callbacks
+ db.exec("DELETE FROM consoles WHERE id > 0");
+
+ assert.deepEqual(updateHookCalls, [
+ {operation: 'delete', databaseName: 'main', tableName: 'consoles', rowId: 1}
+ ], "register the update hook again");
+}
diff --git a/test/test_worker.js b/test/test_worker.js
index 726274eb..42d11db4 100644
--- a/test/test_worker.js
+++ b/test/test_worker.js
@@ -1,77 +1,82 @@
-// TODO: Instead of using puppeteer, we could use the new Node 11 workers via
-// node --experimental-worker test/all.js
-// Then we could do this:
-//const { Worker } = require('worker_threads');
-// But it turns out that the worker_threads interface is just different enough not to work.
-var puppeteer = require("puppeteer");
-var path = require("path");
-var fs = require("fs");
-const { env } = require("process");
+const { Worker } = require("worker_threads");
+const path = require("path");
-class Worker {
- constructor(handle) {
- this.handle = handle;
- }
- static async fromFile(file) {
- const browser = await Worker.launchBrowser();
- const page = await browser.newPage();
- const source = fs.readFileSync(file, 'utf8');
- const worker = await page.evaluateHandle(x => {
- const url = URL.createObjectURL(new Blob([x]), { type: 'application/javascript; charset=utf-8' });
- return new Worker(url);
- }, source);
- return new Worker(worker);
- }
+class SQLWorker {
+ constructor(worker) {
+ this.worker = worker;
+ this.callbacks = new Map();
+ this.nextId = 1;
- static async launchBrowser(){
- try{
- return await puppeteer.launch();
- }
- catch(e){
- if (e.stack.includes('No usable sandbox!')){
- // It's possible that this exception is n expected error related to not having the ability to create a sandboxed user for Puppeteer in Docker.
- // One way around this is to set up the Dockerfile to have a sandboxed user.
- // Details on getting Puppeteer running sandboxed while in Docker are here:
- // https://github.com/puppeteer/puppeteer/blob/main/docs/troubleshooting.md#running-puppeteer-in-docker
- // That seemed kinda complicated, so I'm working around it more quickly/straightforwardly by looking for an env variable we set in the Docker fil `RUN_WORKER_TEST_WITHOUT_PUPPETEER_SANDBOX`.
- // -- Taytay
- if (env['RUN_WORKER_TEST_WITHOUT_PUPPETEER_SANDBOX']=="1"){
- // This tells puppeteer to launch without worrying about the sandbox.
- // That's not "safe" if you don't trust the code you're loading in the browser,
- // but we're in a container and we know what we're testing.
- return await puppeteer.launch({args: ['--no-sandbox', '--disable-setuid-sandbox']});
- }
- else {
- console.warn("Puppeteer can't start due to a sandbox error. (Details follow.)\nFor a quick, but potentially dangerous workaround, you can set the environment variable 'RUN_WORKER_TEST_WITHOUT_PUPETEER_SANDBOX=1'.\nYou can also simply run this test in the Docker container defined in .devcontainer/Dockerfile.");
+ this.worker.stderr.on('data', (data) => {
+ console.log(data);
+ });
+
+ this.worker.stdout.on('data', (data) => {
+ console.log(data);
+ });
+
+ this.worker.on('message', (data) => {
+ if (data.error) {
+ console.log("Worker error: ", data.error);
+ for (const callback of this.callbacks.values()) {
+ callback.reject(data.error);
}
+ return;
}
- // If we're here, we couldn't get out of this cleanly. Re-throw
- throw e;
- }
+ const callback = this.callbacks.get(data.id);
+ if (callback) {
+ this.callbacks.delete(data.id);
+ callback.resolve(data);
+ } else {
+ console.log("Received message from worker but no callback found for id", data);
+ }
+ });
+
+ this.worker.on('error', (err) => {
+ console.log("Worker error", err);
+ for (const callback of this.callbacks.values()) {
+ callback.reject(err);
+ }
+ this.callbacks.clear();
+ });
+ }
+
+ static async fromFile(file) {
+ // Create a worker directly from the file
+ const worker = new Worker(file);
+ return new SQLWorker(worker);
}
async postMessage(msg) {
- return await this.handle.evaluate((worker, msg) => {
- return new Promise((accept, reject) => {
- setTimeout(reject, 20000, new Error("time out"));
- worker.onmessage = evt => accept(evt.data);
- worker.onerror = reject;
- worker.postMessage(msg);
- })
- }, msg);
+ return new Promise((resolve, reject) => {
+ const id = msg.id || this.nextId++;
+ const messageWithId = { ...msg, id };
+
+ this.callbacks.set(id, { resolve, reject });
+
+ // Set a timeout to reject the promise if no response is received
+ setTimeout(() => {
+ if (this.callbacks.has(id)) {
+ this.callbacks.delete(id);
+ reject(new Error("Worker response timeout"));
+ }
+ }, 20000);
+
+ // Send the message to the worker
+ this.worker.postMessage(messageWithId);
+ });
}
}
exports.test = async function test(SQL, assert) {
var target = process.argv[2];
var file = target ? "sql-" + target : "sql-wasm";
- if (file.indexOf('wasm') > -1 || file.indexOf('memory-growth') > -1) {
+ if (file.indexOf('memory-growth') > -1) {
console.error("Skipping worker test for " + file + ". Not implemented yet");
return;
};
- // If we use puppeteer, we need to pass in this new cwd as the root of the file being loaded:
const filename = "../dist/worker." + file + ".js";
- var worker = await Worker.fromFile(path.join(__dirname, filename));
+ var worker = await SQLWorker.fromFile(path.join(__dirname, filename));
var data = await worker.postMessage({ id: 1, action: 'open' });
assert.strictEqual(data.id, 1, "Return the given id in the correct format");
assert.deepEqual(data, { id: 1, ready: true }, 'Correct data answered to the "open" query');
@@ -115,6 +120,9 @@ exports.test = async function test(SQL, assert) {
assert.strictEqual(table.values[2][1], 'c', 'Reading string');
assert.deepEqual(obj2array(table.values[2][2]), [0x00, 0x44], 'Reading BLOB byte');
+ data = await worker.postMessage({ action: 'getRowsModified' });
+ assert.equal(data.rowsModified, 1, 'Number of changed rows')
+
data = await worker.postMessage({ action: 'export' });
var header = "SQLite format 3\0";
var actual = "";
@@ -142,5 +150,4 @@ if (module == require.main) {
exports.test(null, assert).then(done);
}
});
-
}
diff --git a/test/test_workers.html b/test/test_workers.html
new file mode 100644
index 00000000..f0596a36
--- /dev/null
+++ b/test/test_workers.html
@@ -0,0 +1,23 @@
+
+
+ Run python -m http.server 2255,
+ then open this file.
+
