@nshiab/simple-data-analysis-core 2.0.5 → 2.0.7

package/esm/helpers/LogValue.d.ts

@@ -0,0 +1,8 @@
+/** Internal display metadata; never returned by public data extraction. */
+export default class LogValue {
+    readonly text: string;
+    readonly jsType: string;
+    readonly category: "number" | "string" | "date" | "boolean" | "null";
+    constructor(text: string, jsType: string, category: "number" | "string" | "date" | "boolean" | "null");
+}
+//# sourceMappingURL=LogValue.d.ts.map

package/esm/helpers/LogValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogValue.d.ts","sourceRoot":"","sources":["../../src/helpers/LogValue.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,MAAM,CAAC,OAAO,OAAO,QAAQ;IAEzB,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM;gBAF3D,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM;CAEvE"}

package/esm/helpers/LogValue.js

@@ -0,0 +1,23 @@
+/** Internal display metadata; never returned by public data extraction. */
+export default class LogValue {
+    constructor(text, jsType, category) {
+        Object.defineProperty(this, "text", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: text
+        });
+        Object.defineProperty(this, "jsType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: jsType
+        });
+        Object.defineProperty(this, "category", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: category
+        });
+    }
+}

package/esm/helpers/cacheTableDependencies.d.ts

@@ -1,9 +1,18 @@
 import type SimpleTable from "../class/SimpleTable.js";
+import type { PendingOp, PendingOpInput } from "./pendingOps.js";
 import { type TableGenerationId } from "./tableGeneration.js";
 export type CacheTableDependency = {
     tableName: string;
     generationId: TableGenerationId;
 };
+/** Keeps deferred callbacks in their originating cache scope across observers. */
+export declare function captureCacheTableOperation(op: PendingOpInput): PendingOpInput;
+/** Rejects mutations before they can queue work or execute SQL. */
+export declare function assertCacheTableMutation(table: SimpleTable): void;
+/** Tracks callback-owned handles so failure cleanup does not touch other work. */
+export declare function recordCacheTableCreation(table: SimpleTable): void;
+/** Tracks queued work across nested callbacks, including async barriers. */
+export declare function recordCacheTableOperation(table: SimpleTable, op: PendingOp): void;
 /** Records a table read when a cache computation is observing dependencies. */
 export declare function recordCacheTableAccess(table: SimpleTable): void;
 /** Records registered tables named in user-supplied SQL fragments. */

package/esm/helpers/cacheTableDependencies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cacheTableDependencies.d.ts","sourceRoot":"","sources":["../../src/helpers/cacheTableDependencies.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,MAAM,oBAAoB,GAAG;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,iBAAiB,CAAC;CACjC,CAAC;AASF,+EAA+E;AAC/E,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAE/D;AAED,sEAAsE;AACtE,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,SAAS,MAAM,EAAE,GACrB,IAAI,CAcN;AAED,qEAAqE;AACrE,wBAAsB,6BAA6B,CACjD,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAC3B,OAAO,CAAC,oBAAoB,EAAE,CAAC,CA6CjC;AAsBD,2EAA2E;AAC3E,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,SAAS,oBAAoB,EAAE,GAAG,SAAS,GACxD,OAAO,CAYT;AAED,+EAA+E;AAC/E,wBAAgB,oCAAoC,CAClD,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,SAAS,oBAAoB,EAAE,GAC5C,MAAM,CAsBR;AAED,kEAAkE;AAClE,wBAAgB,sCAAsC,CACpD,YAAY,EAAE,SAAS,oBAAoB,EAAE,GAC5C,MAAM,CAER"}
+{"version":3,"file":"cacheTableDependencies.d.ts","sourceRoot":"","sources":["../../src/helpers/cacheTableDependencies.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAWjE,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,MAAM,oBAAoB,GAAG;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,iBAAiB,CAAC;CACjC,CAAC;AAkBF,kFAAkF;AAClF,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,cAAc,GAAG,cAAc,CAiB7E;AAYD,mEAAmE;AACnE,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAWjE;AAED,kFAAkF;AAClF,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CASjE;AAED,4EAA4E;AAC5E,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,WAAW,EAClB,EAAE,EAAE,SAAS,GACZ,IAAI,CAMN;AAED,+EAA+E;AAC/E,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAM/D;AAED,sEAAsE;AACtE,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,SAAS,MAAM,EAAE,GACrB,IAAI,CAON;AAED,qEAAqE;AACrE,wBAAsB,6BAA6B,CACjD,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAC3B,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAsDjC;AA4ED,2EAA2E;AAC3E,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,SAAS,oBAAoB,EAAE,GAAG,SAAS,GACxD,OAAO,CAYT;AAED,+EAA+E;AAC/E,wBAAgB,oCAAoC,CAClD,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,SAAS,oBAAoB,EAAE,GAC5C,MAAM,CAsBR;AAED,kEAAkE;AAClE,wBAAgB,sCAAsC,CACpD,YAAY,EAAE,SAAS,oBAAoB,EAAE,GAC5C,MAAM,CAER"}

package/esm/helpers/cacheTableDependencies.js

@@ -1,22 +1,78 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { getRegisteredTables } from "./tableRegistry.js";
+import referencedTables from "./referencedTables.js";
+import { getAsyncOperationFrame, runWhileDrainingAsyncOperationFrame, } from "./asyncOperationContext.js";
+import flushAllTables, { runExemptFromFlush } from "./flushAllTables.js";
+import quoteIdentifier from "./quoteIdentifier.js";
+import { getRegisteredTables, retainRegisteredTables, } from "./tableRegistry.js";
 import { getTableGeneration, peekTableGeneration, } from "./tableGeneration.js";
 const dependencyContext = new AsyncLocalStorage();
+/** Keeps deferred callbacks in their originating cache scope across observers. */
+export function captureCacheTableOperation(op) {
+    if (op.kind === "barrier" || op.kind === "asyncBarrier") {
+        return { ...op, execute: bindCacheContext(op.execute) };
+    }
+    if (op.kind === "source") {
+        return { ...op, buildSelect: bindCacheContext(op.buildSelect) };
+    }
+    return {
+        ...op,
+        buildSelect: bindCacheContext(op.buildSelect),
+        outputSchema: op.outputSchema === undefined
+            ? undefined
+            : bindCacheContext(op.outputSchema),
+        values: typeof op.values === "function"
+            ? bindCacheContext(op.values)
+            : op.values,
+    };
+}
+function bindCacheContext(callback) {
+    // Capture only the cache scope: a snapshot of all AsyncLocalStorage stores
+    // would also capture stale flush exemptions and async operation frames.
+    // An empty scope keeps unrelated work out of the observer's cache callback.
+    const frames = dependencyContext.getStore() ?? [];
+    return (...args) => dependencyContext.run(frames, () => callback(...args));
+}
+/** Rejects mutations before they can queue work or execute SQL. */
+export function assertCacheTableMutation(table) {
+    for (const frame of dependencyContext.getStore() ?? []) {
+        if (frame.open && table !== frame.cachedTable &&
+            frame.availableBeforeCompute.has(table)) {
+            throw new Error(cacheTableMutationMessage(frame.cachedTable, [table.name]));
+        }
+    }
+}
+/** Tracks callback-owned handles so failure cleanup does not touch other work. */
+export function recordCacheTableCreation(table) {
+    for (const frame of dependencyContext.getStore() ?? []) {
+        if (frame.open && table.sdb === frame.cachedTable.sdb &&
+            !frame.availableBeforeCompute.has(table)) {
+            frame.created.add(table);
+        }
+    }
+}
+/** Tracks queued work across nested callbacks, including async barriers. */
+export function recordCacheTableOperation(table, op) {
+    for (const frame of dependencyContext.getStore() ?? []) {
+        if (frame.open && table.sdb === frame.cachedTable.sdb) {
+            frame.queued.add(op.sequence);
+        }
+    }
+}
 /** Records a table read when a cache computation is observing dependencies. */
 export function recordCacheTableAccess(table) {
-    dependencyContext.getStore()?.add(table);
+    for (const frame of dependencyContext.getStore() ?? []) {
+        if (frame.open && table.sdb === frame.cachedTable.sdb) {
+            frame.accessed.add(table);
+        }
+    }
 }
 /** Records registered tables named in user-supplied SQL fragments. */
 export function recordCacheTableReferences(table, sql) {
     if (dependencyContext.getStore() === undefined) {
         return;
     }
-    for (const candidate of getRegisteredTables(table.sdb)) {
-        const escaped = candidate.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const pattern = new RegExp(`(?<![\\w\"])\"?${escaped}\"?(?![\\w\"])`, "i");
-        if (sql.some((fragment) => pattern.test(fragment))) {
-            recordCacheTableAccess(candidate);
-        }
+    for (const candidate of referencedTables(sql, table.sdb)) {
+        recordCacheTableAccess(candidate);
     }
 }
 /** Runs a cache computation while collecting the tables it reads. */
@@ -29,19 +85,31 @@ export async function captureCacheTableDependencies(cachedTable, compute) {
         },
     ]));
     const accessed = new Set();
-    await dependencyContext.run(accessed, compute);
-    const changedTables = [...availableBeforeCompute]
-        .filter(([table, snapshot]) => table !== cachedTable &&
-        peekTableGeneration(table) !== snapshot.generationId)
-        .map(([, snapshot]) => snapshot.tableName);
-    if (changedTables.length > 0) {
-        throw new Error(cacheTableMutationMessage(cachedTable, changedTables));
-    }
-    const createdTables = getRegisteredTables(cachedTable.sdb)
-        .filter((table) => !availableBeforeCompute.has(table))
-        .map((table) => table.name);
-    if (createdTables.length > 0) {
-        throw new Error(cacheTableCleanupMessage(createdTables));
+    const frame = {
+        cachedTable,
+        availableBeforeCompute,
+        accessed,
+        created: new Set(),
+        queued: new Set(),
+        open: true,
+    };
+    try {
+        await dependencyContext.run([...(dependencyContext.getStore() ?? []), frame], async () => {
+            await compute();
+            // A callback can queue a whole computation without observing it.
+            // Reject leaked handles before executing that pending computation.
+            assertCacheTableCleanup(frame);
+            await flushAllTables(cachedTable.sdb);
+            // Async barriers may create tables during the final flush.
+            assertCacheTableCleanup(frame);
+        });
+    }
+    catch (error) {
+        await cleanupCacheComputation(frame);
+        throw error;
+    }
+    finally {
+        frame.open = false;
     }
     return [...accessed]
         .filter((table) => table !== cachedTable && availableBeforeCompute.has(table))
@@ -57,6 +125,48 @@ export async function captureCacheTableDependencies(cachedTable, compute) {
     })
         .sort((left, right) => left.tableName.localeCompare(right.tableName));
 }
+function assertCacheTableCleanup(frame) {
+    const created = getRegisteredTables(frame.cachedTable.sdb)
+        .filter((table) => frame.created.has(table));
+    if (created.length > 0) {
+        throw new Error(cacheTableCleanupMessage(created.map((table) => table.name)));
+    }
+}
+async function cleanupCacheComputation(frame) {
+    const sdb = frame.cachedTable.sdb;
+    // Drop only this callback's pending operations, preserving other queues and
+    // their database-wide ordering. A nested failure also discards work captured
+    // by an enclosing async barrier, which is stored outside pendingOps.
+    for (const table of getRegisteredTables(sdb)) {
+        const retained = table.pendingOps.filter((op) => !frame.queued.has(op.sequence));
+        sdb.pendingCount -= table.pendingOps.length - retained.length;
+        table.pendingOps.splice(0, table.pendingOps.length, ...retained);
+    }
+    const operationFrame = getAsyncOperationFrame(sdb);
+    if (operationFrame !== undefined) {
+        operationFrame.entries = operationFrame.entries.filter((entry) => !frame.queued.has(entry.op.sequence));
+    }
+    const created = getRegisteredTables(sdb)
+        .filter((table) => frame.created.has(table));
+    if (created.length === 0)
+        return;
+    // Observers inside compute may already have materialized temporary tables.
+    // Cleanup must not flush work requeued after an execution error.
+    const removeCreatedTables = () => runExemptFromFlush(sdb, async () => {
+        for (const table of created) {
+            await sdb.customQuery(`DROP TABLE IF EXISTS ${quoteIdentifier(table.name)};`);
+        }
+    });
+    if (operationFrame === undefined) {
+        await removeCreatedTables();
+    }
+    else {
+        // Async frames take precedence over the database-wide flush exemption.
+        // Suppress their drain too, without consuming unrelated captured work.
+        await runWhileDrainingAsyncOperationFrame(operationFrame, removeCreatedTables);
+    }
+    retainRegisteredTables(sdb, (table) => !frame.created.has(table));
+}
 function cacheTableMutationMessage(cachedTable, changedTables) {
     const tables = changedTables.map((name) => JSON.stringify(name)).join(", ");
     const cachedTableName = JSON.stringify(cachedTable.name);

package/esm/helpers/cleanSQL.d.ts

@@ -1,2 +1,2 @@
-export default function cleanSQL(query: string): string;
+export default function cleanSQL(query: string, syntax?: "js" | "sql"): string;
 //# sourceMappingURL=cleanSQL.d.ts.map

package/esm/helpers/cleanSQL.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cleanSQL.d.ts","sourceRoot":"","sources":["../../src/helpers/cleanSQL.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA8BtD"}
+{"version":3,"file":"cleanSQL.d.ts","sourceRoot":"","sources":["../../src/helpers/cleanSQL.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,IAAI,GAAG,KAAY,GAC1B,MAAM,CAqRR"}

package/esm/helpers/cleanSQL.js

@@ -1,24 +1,269 @@
-export default function cleanSQL(query) {
-    // First pass
-    let cleaned = query
-        .replace(/ && /g, " AND ")
-        .replace(/ === /g, " = ")
-        .replace(/ == /g, " = ")
-        .replace(/ !== /g, " != ");
-    // Replace || with OR only in WHERE clauses (for logical operations)
-    // Preserve || elsewhere as it's the SQL concatenation operator
-    cleaned = cleaned.replace(/WHERE\s+([\s\S]*?)(?=\s+(?:GROUP BY|ORDER BY|LIMIT|HAVING)|$)/gi, (match) => {
-        return match.replace(/\s*\|\|\s*/g, " OR ");
-    });
-    if (cleaned.includes("ALTER TABLE") && cleaned.includes("UPDATE") &&
-        cleaned.includes("SET")) {
-        // We pass
-    }
-    else {
-        // We do a second pass
-        cleaned = cleaned.replace(/ null(?=\s|$)/g, " NULL") // space after or end of string
-            .replace(/ != NULL/g, " NOT NULL")
-            .replace(/ = NULL/g, " IS NULL");
-    }
-    return cleaned.trim();
+import scanSQL from "./scanSQL.js";
+export default function cleanSQL(query, syntax = "js") {
+    if (syntax === "sql")
+        return query;
+    const tokens = scanSQL(query);
+    const significant = tokens.filter((token) => token.kind !== "trivia");
+    const original = significant.map((token) => token.kind === "sql" ? token.text.toUpperCase() : "");
+    const pairs = new Map();
+    const stack = [];
+    for (let i = 0; i < original.length; i++) {
+        if (["(", "[", "CASE"].includes(original[i]))
+            stack.push(i);
+        else if (stack.length &&
+            ((original[i] === ")" && original[stack[stack.length - 1]] === "(") ||
+                (original[i] === "]" && original[stack[stack.length - 1]] === "[") ||
+                (original[i] === "END" && original[stack[stack.length - 1]] === "CASE"))) {
+            const start = stack.pop();
+            pairs.set(start, i);
+            pairs.set(i, start);
+        }
+    }
+    const betweenAnd = new Set();
+    for (let i = 0; i < original.length; i++) {
+        if (original[i] !== "BETWEEN")
+            continue;
+        for (let j = i + 1; j < original.length; j++) {
+            if (["(", "[", "CASE"].includes(original[j])) {
+                j = pairs.get(j) ?? original.length;
+            }
+            else if ([")", "]", "END", ";"].includes(original[j]))
+                break;
+            else if (original[j] === "AND") {
+                betweenAnd.add(j);
+                break;
+            }
+        }
+    }
+    const comparisons = new Set([
+        "=",
+        "==",
+        "===",
+        "!=",
+        "!==",
+        "<>",
+        "<",
+        ">",
+        "<=",
+        ">=",
+        "IS",
+        "IN",
+        "LIKE",
+        "ILIKE",
+        "BETWEEN",
+    ]);
+    const boundaries = new Set([
+        "SELECT",
+        "FROM",
+        "WHERE",
+        "HAVING",
+        "QUALIFY",
+        "GROUP",
+        "ORDER",
+        "LIMIT",
+        "RETURNING",
+        "UNION",
+        "EXCEPT",
+        "INTERSECT",
+        "WHEN",
+        "THEN",
+        "ELSE",
+        "AS",
+        "AND",
+        "OR",
+        "&&",
+        ",",
+        ";",
+    ]);
+    const textTypes = new Set(["VARCHAR", "CHAR", "BPCHAR", "TEXT", "STRING"]);
+    function range(pipe, start, end, stop) {
+        let left = pipe - 1;
+        while (left >= start && !stop(left)) {
+            if ([")", "]", "END"].includes(original[left])) {
+                left = pairs.get(left) ?? start;
+            }
+            left--;
+        }
+        let right = pipe + 1;
+        while (right < end && !stop(right)) {
+            if (["(", "[", "CASE"].includes(original[right])) {
+                right = pairs.get(right) ?? end;
+            }
+            right++;
+        }
+        return [left + 1, right];
+    }
+    function predicate(start, end) {
+        if (original[start] === "(" && pairs.get(start) === end - 1) {
+            return predicate(start + 1, end - 1);
+        }
+        for (let i = start; i < end; i++) {
+            if (["(", "[", "CASE"].includes(original[i]))
+                i = pairs.get(i) ?? end;
+            else if (comparisons.has(original[i]))
+                return true;
+        }
+        return false;
+    }
+    // Only infer types that are explicit in the expression. Never infer a
+    // column's or an arbitrary function's type from its name or argument types.
+    function isTextType(start, end) {
+        return textTypes.has(original[start]) &&
+            (start + 1 === end ||
+                (original[start + 1] === "(" && pairs.get(start + 1) === end - 1));
+    }
+    function concatenable(start, end) {
+        if (start >= end)
+            return false;
+        let cast;
+        let pipe;
+        for (let i = start; i < end; i++) {
+            if (["(", "[", "CASE"].includes(original[i]))
+                i = pairs.get(i) ?? end;
+            else if (comparisons.has(original[i]))
+                return false;
+            else if (original[i] === "||")
+                pipe ??= i;
+            else if (original[i] === "::")
+                cast = i;
+        }
+        if (pipe !== undefined) {
+            return concatenable(start, pipe) || concatenable(pipe + 1, end);
+        }
+        // The final cast determines the result type, including casts to BOOLEAN.
+        if (cast !== undefined) {
+            return isTextType(cast + 1, end);
+        }
+        if (original[start] === "(" && pairs.get(start) === end - 1) {
+            return concatenable(start + 1, end - 1);
+        }
+        if (original[start] === "[" && pairs.get(start) === end - 1)
+            return true;
+        if (end === start + 1) {
+            return significant[start].kind === "quoted" &&
+                !significant[start].text.startsWith('"');
+        }
+        if (original[start + 1] === "(" && pairs.get(start + 1) === end - 1) {
+            if (["CONCAT", "CONCAT_WS"].includes(original[start]))
+                return true;
+            if (["CAST", "TRY_CAST"].includes(original[start])) {
+                for (let i = start + 2; i < end - 1; i++) {
+                    if (["(", "[", "CASE"].includes(original[i])) {
+                        i = pairs.get(i) ?? end;
+                    }
+                    else if (original[i] === "AS") {
+                        return isTextType(i + 1, end - 1);
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    function obviousConcatenation(pipe, start, end) {
+        const [left, right] = range(pipe, start, end, (i) => (boundaries.has(original[i]) && !betweenAnd.has(i)) ||
+            original[i] === "||");
+        // A literal in a comparison is not evidence that the comparison returns text.
+        if (predicate(left, pipe) && predicate(pipe + 1, right))
+            return false;
+        const [groupStart, groupEnd] = range(pipe, start, end, (i) => boundaries.has(original[i]) || comparisons.has(original[i]));
+        let operand = groupStart;
+        for (let i = groupStart; i <= groupEnd; i++) {
+            if (["(", "[", "CASE"].includes(original[i])) {
+                i = pairs.get(i) ?? groupEnd;
+            }
+            else if (i === groupEnd || original[i] === "||") {
+                // Do not use the RHS literal of a preceding comparison to infer OR's
+                // meaning (text = 'a' || active). Other operands can still prove concat.
+                if (!(operand === groupStart &&
+                    (comparisons.has(original[groupStart - 1]) ||
+                        betweenAnd.has(groupStart - 1))) &&
+                    concatenable(operand, i))
+                    return true;
+                operand = i + 1;
+            }
+        }
+        return false;
+    }
+    function normalize(start, end) {
+        let statement = original[start];
+        let inSetClause = false;
+        let assignmentTarget = false;
+        for (let i = start; i < end; i++) {
+            const word = original[i];
+            if (statement === undefined)
+                statement = word;
+            // Nested queries are visited separately below. Look through statement
+            // prefixes to find the outer command that can introduce assignments.
+            if (["WITH", "EXPLAIN", "PREPARE"].includes(statement) &&
+                ["SELECT", "INSERT", "UPDATE", "DELETE", "MERGE"].includes(word))
+                statement = word;
+            if (word === "UPDATE" && ["DO", "THEN"].includes(original[i - 1]))
+                statement = word;
+            if (["(", "[", "CASE"].includes(word)) {
+                const close = pairs.get(i);
+                if (close !== undefined) {
+                    normalize(i + 1, close);
+                    i = close;
+                    continue;
+                }
+            }
+            if (["WHERE", "HAVING", "QUALIFY", "WHEN"].includes(word)) {
+                statement = word;
+                inSetClause = false;
+                assignmentTarget = false;
+            }
+            else if ([
+                "THEN",
+                "ELSE",
+                "SELECT",
+                "FROM",
+                "GROUP",
+                "ORDER",
+                "LIMIT",
+                "RETURNING",
+                "UNION",
+                "EXCEPT",
+                "INTERSECT",
+                ";",
+            ].includes(word)) {
+                statement = word;
+                inSetClause = false;
+                assignmentTarget = false;
+            }
+            else if (word === "SET" && !inSetClause &&
+                (statement === "UPDATE" ||
+                    (statement === "SET" &&
+                        (original[i + 1] === "VARIABLE" || original[i + 2] === "=")))) {
+                inSetClause = true;
+                assignmentTarget = true;
+            }
+            else if (word === "," && inSetClause)
+                assignmentTarget = true;
+            if (word === ";")
+                statement = undefined;
+            // Preserve only the assignment operator itself. Comparisons in its RHS
+            // still use shorthand, even when they are not wrapped in parentheses.
+            const assignment = assignmentTarget && ["=", "==", "==="].includes(word);
+            if (assignment)
+                assignmentTarget = false;
+            const token = significant[i];
+            if (["==", "==="].includes(word))
+                token.text = "=";
+            else if (word === "!==")
+                token.text = "!=";
+            else if (word === "&&")
+                token.text = " AND ";
+            else if (word === "||" && !obviousConcatenation(i, start, end)) {
+                token.text = " OR ";
+            }
+            if (original[i + 1] === "NULL" && !assignment) {
+                if (["=", "==", "==="].includes(word))
+                    token.text = " IS ";
+                else if (["!=", "!=="].includes(word))
+                    token.text = " IS NOT ";
+            }
+        }
+    }
+    normalize(0, significant.length);
+    return tokens.map((token) => token.text).join("").trim();
 }

package/esm/helpers/flushAllTables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flushAllTables.d.ts","sourceRoot":"","sources":["../../src/helpers/flushAllTables.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AAiCjD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,GAAG,EAAE,QAAQ,EACb,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAIZ;AAED;;;;;;;;;;;;GAYG;AACH,wBAA8B,cAAc,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAgCzE"}
+{"version":3,"file":"flushAllTables.d.ts","sourceRoot":"","sources":["../../src/helpers/flushAllTables.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AAkCjD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,GAAG,EAAE,QAAQ,EACb,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAIZ;AAED;;;;;;;;;;;;GAYG;AACH,wBAA8B,cAAc,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAgCzE"}