Print all the rows of the table test to the console
@@ -449,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;"
@@ -535,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;
@@ -553,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,
@@ -638,7 +644,7 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
};
/** Bind values to numbered parameters
- @param {Database.SqlValue[]} values
+ @param {Array} values
@private
@nodoc
*/
@@ -649,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.
*/
@@ -724,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;
@@ -819,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) {
@@ -872,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
*/
@@ -934,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;
@@ -984,7 +992,7 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
if (stmt) stmt["free"]();
throw errCaught;
} finally {
- stackRestore(stack);
+ if (originalSqlPtr) _free(originalSqlPtr);
}
};
@@ -995,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
@@ -1008,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;
@@ -1074,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() {
@@ -1087,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;
};
@@ -1110,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;
@@ -1184,14 +1200,17 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
if (result === null) {
sqlite3_result_null(cx);
} else if (result.length != null) {
- var blobptr = allocate(result, ALLOC_NORMAL);
+ 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 "
+ sqlite3_result_error(
+ cx, (
+ "Wrong API use : tried to return a value "
+ "of an unknown type (" + result + ")."
- ), -1);
+ ), -1
+ );
}
break;
default:
@@ -1206,7 +1225,7 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
@param {string} name the name of the function as referenced in
SQL statements.
- @param {function} func the actual function to be executed.
+ @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(
@@ -1259,7 +1278,7 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
SQL statements.
@param {object} aggregateFunctions
object containing at least a step function.
- @param {function(): T} [aggregateFunctions.init = ()=>null]
+ @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.
@@ -1267,7 +1286,7 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
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 = (state)=>state]
+ @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
@@ -1377,6 +1396,143 @@ Module["onRuntimeInitialized"] = function onRuntimeInitialized() {
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 324017ae..3be25955 100644
--- a/src/exported_functions.json
+++ b/src/exported_functions.json
@@ -42,5 +42,6 @@
"_sqlite3_result_int64",
"_sqlite3_result_error",
"_sqlite3_aggregate_context",
-"_RegisterExtensionFunctions"
+"_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_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.
+
