@nshiab/simple-data-analysis-core 1.0.0 → 2.0.0

package/esm/methods/convert.d.ts

@@ -0,0 +1,13 @@
+import type SimpleTable from "../class/SimpleTable.js";
+import type { TableSchema } from "../helpers/pendingOps.js";
+export default function convert(simpleTable: SimpleTable, types: {
+    [key: string]: "integer" | "float" | "number" | "string" | "date" | "time" | "datetime" | "datetimeTz" | "bigint" | "double" | "varchar" | "timestamp" | "timestamp with time zone" | "boolean";
+}, options?: {
+    strict?: boolean;
+    datetimeFormat?: string;
+}): void;
+export declare function convertSelect(input: string, columns: string[], columnsTypes: ("integer" | "float" | "number" | "string" | "date" | "time" | "datetime" | "datetimeTz" | "bigint" | "double" | "varchar" | "timestamp" | "timestamp with time zone" | "boolean")[], allColumns: string[], allTypes: TableSchema, options: {
+    datetimeFormat?: string;
+    strict?: boolean;
+}): string;
+//# sourceMappingURL=convert.d.ts.map

package/esm/methods/convert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../src/methods/convert.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE5D,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE;IACL,CAAC,GAAG,EAAE,MAAM,GACR,SAAS,GACT,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,MAAM,GACN,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,WAAW,GACX,0BAA0B,GAC1B,SAAS,CAAC;CACf,EACD,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACpB,QA+CP;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EAAE,EACjB,YAAY,EAAE,CACV,SAAS,GACT,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,MAAM,GACN,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,WAAW,GACX,0BAA0B,GAC1B,SAAS,CACZ,EAAE,EACH,UAAU,EAAE,MAAM,EAAE,EACpB,QAAQ,EAAE,WAAW,EACrB,OAAO,EAAE;IAAE,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,UAgFvD"}

package/esm/methods/convert.js

@@ -0,0 +1,112 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import parseType from "../helpers/parseTypes.js";
+import queueOp from "../helpers/queueOp.js";
+export default function convert(simpleTable, types, options = {}) {
+    types = structuredClone(types);
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "convert()",
+        parameters: { types, options },
+        needsSchema: true,
+        outputSchema: (allTypes) => ({
+            ...allTypes,
+            ...Object.fromEntries(Object.entries(types).map(([column, type]) => [
+                column,
+                parseType(type),
+            ])),
+        }),
+        values: (allTypes) => getDatetimeFormatValues(Object.keys(types), Object.values(types), Object.keys(allTypes), allTypes, options),
+        buildSelect: (input, allTypes) => {
+            const allColumns = Object.keys(allTypes);
+            for (const col in types) {
+                if (!allColumns.includes(col)) {
+                    throw new Error(`The column ${col} does not exist in the table.`);
+                }
+            }
+            return convertSelect(input, Object.keys(types), Object.values(types), allColumns, allTypes, options);
+        },
+    });
+}
+export function convertSelect(input, columns, columnsTypes, allColumns, allTypes, options) {
+    let query = `SELECT`;
+    const cast = options.strict === false ? "TRY_CAST" : "CAST";
+    for (const column of allColumns) {
+        const indexOf = columns.indexOf(column);
+        if (indexOf === -1) {
+            query += ` ${quoteIdentifier(column)},`;
+        }
+        else {
+            const expectedType = parseType(columnsTypes[indexOf]);
+            const currentType = allTypes[column];
+            const datetimeFormatExist = typeof options.datetimeFormat === "string";
+            const stringToNumber = currentType === "VARCHAR" &&
+                ["DOUBLE", "BIGINT"].includes(expectedType);
+            const stringToDate = currentType === "VARCHAR" &&
+                (expectedType.includes("TIME") || expectedType.includes("DATE"));
+            const dateToString = (currentType.includes("DATE") ||
+                currentType.includes("TIME")) &&
+                expectedType === "VARCHAR";
+            const timeToMs = currentType.includes("TIME") &&
+                ["DOUBLE", "BIGINT"].includes(expectedType);
+            const dateToMs = currentType.includes("DATE") &&
+                ["DOUBLE", "BIGINT"].includes(expectedType);
+            const msToTime = ["DOUBLE", "BIGINT"].includes(currentType) &&
+                expectedType === "TIME";
+            const msToDate = ["DOUBLE", "BIGINT"].includes(currentType) &&
+                expectedType.includes("DATE");
+            const msToTimestamp = ["DOUBLE", "BIGINT"].includes(currentType) &&
+                expectedType.includes("TIMESTAMP");
+            if (datetimeFormatExist && stringToDate) {
+                query += ` strptime(${quoteIdentifier(column)}, ?) AS ${quoteIdentifier(column)},`;
+            }
+            else if (datetimeFormatExist && dateToString) {
+                query += ` strftime(${quoteIdentifier(column)}, ?) AS ${quoteIdentifier(column)},`;
+            }
+            else if (timeToMs) {
+                query += ` date_part('epoch', ${quoteIdentifier(column)}) * 1000 AS ${quoteIdentifier(column)},`;
+            }
+            else if (dateToMs) {
+                query += ` epoch(${quoteIdentifier(column)}) * 1000 AS ${quoteIdentifier(column)},`;
+            }
+            else if (msToTime) {
+                query += ` TIME '00:00:00' + to_milliseconds(${quoteIdentifier(column)}) AS ${quoteIdentifier(column)},`;
+            }
+            else if (msToDate) {
+                query += ` DATE '1970-01-01' + to_milliseconds(${quoteIdentifier(column)}) AS ${quoteIdentifier(column)},`;
+            }
+            else if (msToTimestamp) {
+                query += ` TIMESTAMP '1970-01-01 00:00:00' + to_milliseconds(${quoteIdentifier(column)}) AS ${quoteIdentifier(column)},`;
+            }
+            else if (stringToNumber) {
+                // Thousand separators would make the cast fail.
+                query += ` ${cast}(REPLACE(${quoteIdentifier(column)}, ',', '') AS ${parseType(columnsTypes[indexOf])}) AS ${quoteIdentifier(column)},`;
+            }
+            else {
+                query += ` ${cast}(${quoteIdentifier(columns[indexOf])} AS ${parseType(columnsTypes[indexOf])}) AS ${quoteIdentifier(columns[indexOf])},`;
+            }
+        }
+    }
+    query = query.slice(0, query.length - 1);
+    query += ` FROM ${input}`;
+    return query;
+}
+function getDatetimeFormatValues(columns, columnsTypes, allColumns, allTypes, options) {
+    const datetimeFormat = options.datetimeFormat;
+    if (typeof datetimeFormat !== "string") {
+        return [];
+    }
+    return allColumns.flatMap((column) => {
+        const index = columns.indexOf(column);
+        if (index === -1) {
+            return [];
+        }
+        const currentType = allTypes[column];
+        const expectedType = parseType(columnsTypes[index]);
+        const stringToDate = currentType === "VARCHAR" &&
+            (expectedType.includes("TIME") || expectedType.includes("DATE"));
+        const dateToString = (currentType.includes("DATE") ||
+            currentType.includes("TIME")) && expectedType === "VARCHAR";
+        return stringToDate || dateToString ? [datetimeFormat] : [];
+    });
+}

package/esm/methods/correlations.d.ts

@@ -1,9 +1,9 @@
 import type SimpleTable from "../class/SimpleTable.js";
-export default function correlations(SimpleTable: SimpleTable, options?: {
+export default function correlations(simpleTable: SimpleTable, options?: {
     x?: string;
     y?: string;
-    categories?: string | string[];
+    by?: string | string[];
     decimals?: number;
     outputTable?: string | boolean;
-}): Promise<void>;
+}): SimpleTable;
 //# sourceMappingURL=correlations.d.ts.map

package/esm/methods/correlations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"correlations.d.ts","sourceRoot":"","sources":["../../src/methods/correlations.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,YAAY,CACxC,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE;IACP,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,iBA2CP"}
+{"version":3,"file":"correlations.d.ts","sourceRoot":"","sources":["../../src/methods/correlations.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE;IACP,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,GACL,WAAW,CA2Db"}

package/esm/methods/correlations.js

@@ -1,21 +1,57 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
 import getCombinations from "../helpers/getCombinations.js";
-import keepNumericalColumns from "../helpers/keepNumericalColumns.js";
 import mergeOptions from "../helpers/mergeOptions.js";
 import queryDB from "../helpers/queryDB.js";
-import correlationsQuery from "./correlationsQuery.js";
-export default async function correlations(SimpleTable, options = {}) {
-    const outputTable = typeof options.outputTable === "string"
-        ? options.outputTable
-        : SimpleTable.name;
+import queueOp from "../helpers/queueOp.js";
+import resolveOutputTable from "../helpers/resolveOutputTable.js";
+import stringToArray from "../helpers/stringToArray.js";
+import validateNumericalAnalysis from "../helpers/validateNumericalAnalysis.js";
+export default function correlations(simpleTable, options = {}) {
+    options = structuredClone(options);
+    options.outputTable = resolveOutputTable(simpleTable, options.outputTable);
+    if (typeof options.outputTable === "string") {
+        // The output table instance is created at call time so it can be
+        // returned synchronously and chained on right away.
+        const outputTable = simpleTable.sdb.newTable(options.outputTable);
+        queueOp(outputTable, {
+            kind: "barrier",
+            method: "correlations()",
+            parameters: { options },
+            execute: async () => {
+                const combinations = getCorrelationsCombinations(await simpleTable.getTypes(), options, simpleTable.name);
+                await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable.name)} AS ${correlationsSelect(`${quoteIdentifier(simpleTable.name)}`, combinations, options)}`, mergeOptions(simpleTable, {
+                    table: outputTable.name,
+                    method: "correlations()",
+                    parameters: {
+                        options,
+                        "combinations (computed)": combinations,
+                    },
+                    values: correlationsValues(combinations),
+                }));
+            },
+        });
+        return outputTable;
+    }
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "correlations()",
+        parameters: { options },
+        needsSchema: true,
+        values: (types) => correlationsValues(getCorrelationsCombinations(types, options, simpleTable.name)),
+        buildSelect: (input, types) => correlationsSelect(input, getCorrelationsCombinations(types, options, simpleTable.name), options),
+    });
+    return simpleTable;
+}
+function correlationsValues(combinations) {
+    return combinations.flatMap(([x, y]) => [x, y]);
+}
+function getCorrelationsCombinations(types, options, tableName) {
+    const columns = validateNumericalAnalysis(types, options, "correlations()", tableName);
     let combinations = [];
-    if (!options.x && !options.y) {
-        const types = await SimpleTable.getTypes();
-        const columns = keepNumericalColumns(types);
+    if (options.x === undefined) {
         combinations = getCombinations(columns, 2);
     }
-    else if (options.x && !options.y) {
-        const types = await SimpleTable.getTypes();
-        const columns = keepNumericalColumns(types);
+    else if (options.y === undefined) {
         combinations = [];
         for (const col of columns) {
             if (col !== options.x) {
@@ -23,18 +59,28 @@ export default async function correlations(SimpleTable, options = {}) {
             }
         }
     }
-    else if (options.x && options.y) {
-        combinations = [[options.x, options.y]];
-    }
     else {
-        throw new Error("No combinations of x and y");
+        combinations = [[options.x, options.y]];
     }
-    await queryDB(SimpleTable, correlationsQuery(SimpleTable.name, outputTable, combinations, options), mergeOptions(SimpleTable, {
-        table: outputTable,
-        method: "correlations()",
-        parameters: {
-            options,
-            "combinations (computed)": combinations,
-        },
-    }));
+    return combinations;
+}
+function correlationsSelect(input, combinations, options) {
+    const by = options.by ? stringToArray(options.by) : [];
+    const groupBy = by.length === 0
+        ? ""
+        : ` GROUP BY ${by.map((d) => `${quoteIdentifier(d)}`).join(",")}`;
+    const catSelect = by.length > 0
+        ? `${by.map((d) => `${quoteIdentifier(d)}`).join(",")}, `
+        : "";
+    // One UNION ALL branch per pair (each with a distinct pair of literals, so
+    // deduplication would never remove anything). DuckDB runs the branches as
+    // concurrent pipelines, which parallelizes the aggregates better than
+    // computing them all in one scan.
+    const branches = combinations.map((comb) => {
+        const expression = typeof options.decimals === "number"
+            ? `ROUND(corr(${quoteIdentifier(comb[0])}, ${quoteIdentifier(comb[1])}), ${options.decimals})`
+            : `corr(${quoteIdentifier(comb[0])}, ${quoteIdentifier(comb[1])})`;
+        return `SELECT ${catSelect}? AS ${quoteIdentifier("x")}, ? AS ${quoteIdentifier("y")}, ${expression} AS ${quoteIdentifier("corr")} FROM ${input}${groupBy}`;
+    });
+    return branches.join("\nUNION ALL\n");
 }

package/esm/methods/coveredBy.d.ts

@@ -0,0 +1,3 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function coveredBy(simpleTable: SimpleTable, column: string, containerColumn: string, newColumn: string): void;
+//# sourceMappingURL=coveredBy.d.ts.map

package/esm/methods/coveredBy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coveredBy.d.ts","sourceRoot":"","sources":["../../src/methods/coveredBy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,MAAM,EACvB,SAAS,EAAE,MAAM,QAelB"}

package/esm/methods/coveredBy.js

@@ -0,0 +1,16 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import assertNewColumns from "../helpers/assertNewColumns.js";
+import queueOp from "../helpers/queueOp.js";
+export default function coveredBy(simpleTable, column, containerColumn, newColumn) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "coveredBy()",
+        parameters: { column, containerColumn, newColumn },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            assertNewColumns(types, [newColumn], "coveredBy()");
+            return `SELECT *, CAST(ST_Covers(${quoteIdentifier(containerColumn)}, ${quoteIdentifier(column)}) AS BOOLEAN) AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}

package/esm/methods/createFtsIndex.d.ts

@@ -1,5 +1,5 @@
 import type SimpleTable from "../class/SimpleTable.js";
-export default function createFtsIndex(simpleTable: SimpleTable, columnId: string, columnText: string, options?: {
+export default function createFtsIndex(simpleTable: SimpleTable, idColumn: string, textColumn: string, options?: {
     stemmer?: "arabic" | "basque" | "catalan" | "danish" | "dutch" | "english" | "finnish" | "french" | "german" | "greek" | "hindi" | "hungarian" | "indonesian" | "irish" | "italian" | "lithuanian" | "nepali" | "norwegian" | "porter" | "portuguese" | "romanian" | "russian" | "serbian" | "spanish" | "swedish" | "tamil" | "turkish" | "none";
     stopwords?: string;
     ignore?: string;
@@ -7,5 +7,18 @@ export default function createFtsIndex(simpleTable: SimpleTable, columnId: strin
     lower?: boolean;
     overwrite?: boolean;
     verbose?: boolean;
-}): Promise<SimpleTable>;
+}): void;
+/**
+ * Creates the index immediately, without queueing. For use inside a
+ * barrier's execute, which runs during a flush.
+ */
+export declare function executeCreateFtsIndex(simpleTable: SimpleTable, idColumn: string, textColumn: string, options: {
+    stemmer?: string;
+    stopwords?: string;
+    ignore?: string;
+    stripAccents?: boolean;
+    lower?: boolean;
+    overwrite?: boolean;
+    verbose?: boolean;
+}): Promise<void>;
 //# sourceMappingURL=createFtsIndex.d.ts.map

package/esm/methods/createFtsIndex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createFtsIndex.d.ts","sourceRoot":"","sources":["../../src/methods/createFtsIndex.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,cAAc,CAC1C,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE;IACP,OAAO,CAAC,EACJ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,OAAO,GACP,SAAS,GACT,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,OAAO,GACP,WAAW,GACX,YAAY,GACZ,OAAO,GACP,SAAS,GACT,YAAY,GACZ,QAAQ,GACR,WAAW,GACX,QAAQ,GACR,YAAY,GACZ,UAAU,GACV,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,GACT,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,wBAkDP"}
+{"version":3,"file":"createFtsIndex.d.ts","sourceRoot":"","sources":["../../src/methods/createFtsIndex.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE;IACP,OAAO,CAAC,EACJ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,OAAO,GACP,SAAS,GACT,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,OAAO,GACP,WAAW,GACX,YAAY,GACZ,OAAO,GACP,SAAS,GACT,YAAY,GACZ,QAAQ,GACR,WAAW,GACX,QAAQ,GACR,YAAY,GACZ,UAAU,GACV,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,GACT,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,QAWP;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE;IACP,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GACA,OAAO,CAAC,IAAI,CAAC,CAgEf"}

package/esm/methods/createFtsIndex.js

@@ -1,28 +1,67 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
 import camelCase from "../helpers/camelCase.js";
-export default async function createFtsIndex(simpleTable, columnId, columnText, options = {}) {
+import queueOp from "../helpers/queueOp.js";
+import buildCreateIndexQuery from "../helpers/indexQueries.js";
+export default function createFtsIndex(simpleTable, idColumn, textColumn, options = {}) {
+    // Index creation is multi-statement by nature: it executes as a barrier.
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "barrier",
+        method: "createFtsIndex()",
+        parameters: { idColumn, textColumn, options },
+        execute: () => executeCreateFtsIndex(simpleTable, idColumn, textColumn, options),
+    });
+}
+/**
+ * Creates the index immediately, without queueing. For use inside a
+ * barrier's execute, which runs during a flush.
+ */
+export async function executeCreateFtsIndex(simpleTable, idColumn, textColumn, options) {
     const indexName = `fts_index_${camelCase(simpleTable.name)}`;
-    const indexExists = simpleTable.indexes.includes(indexName);
+    const indexPosition = simpleTable.indexes.findIndex(({ name }) => name === indexName);
+    const indexExists = indexPosition >= 0;
     if (indexExists && options.overwrite) {
         options.verbose &&
-            console.log(`\nDropping existing FTS index on "${columnText}" column...`);
-        await simpleTable.sdb.customQuery(`PRAGMA drop_fts_index("${simpleTable.name}");`);
+            console.log(`\nDropping existing FTS index on ${quoteIdentifier(textColumn)} column...`);
+        await simpleTable.sdb.customQuery(`PRAGMA drop_fts_index(${quoteIdentifier(simpleTable.name)});`);
         options.verbose && console.log("FTS index dropped.");
     }
     if (!indexExists || options.overwrite) {
         options.verbose &&
-            console.log(`\nCreating FTS index on "${columnText}" column...`);
-        await simpleTable.sdb.customQuery(`PRAGMA create_fts_index("${simpleTable.name}", "${columnId}", "${columnText}"${options.stemmer ? `, stemmer = '${options.stemmer}'` : ""}${options.stopwords ? `, stopwords = '${options.stopwords}'` : ""}${options.ignore ? `, ignore = '${options.ignore}'` : ""}${typeof options.stripAccents === "boolean"
-            ? `, strip_accents = ${options.stripAccents ? 1 : 0}`
-            : ""}${typeof options.lower === "boolean"
-            ? `, lower = ${options.lower ? 1 : 0}`
-            : ""});`);
-        if (!simpleTable.indexes.includes(indexName)) {
-            simpleTable.indexes.push(indexName);
+            console.log(`\nCreating FTS index on ${quoteIdentifier(textColumn)} column...`);
+        const indexOptions = {};
+        if (options.stemmer !== undefined) {
+            indexOptions.stemmer = options.stemmer;
+        }
+        if (options.stopwords !== undefined) {
+            indexOptions.stopwords = options.stopwords;
+        }
+        if (options.ignore !== undefined) {
+            indexOptions.ignore = options.ignore;
+        }
+        if (options.stripAccents !== undefined) {
+            indexOptions.stripAccents = options.stripAccents;
+        }
+        if (options.lower !== undefined) {
+            indexOptions.lower = options.lower;
+        }
+        const definition = {
+            kind: "fts",
+            name: indexName,
+            idColumn,
+            textColumn,
+            options: indexOptions,
+        };
+        await simpleTable.sdb.customQuery(buildCreateIndexQuery(simpleTable.name, definition));
+        if (indexExists) {
+            simpleTable.indexes[indexPosition] = definition;
+        }
+        else {
+            simpleTable.indexes.push(definition);
         }
         options.verbose && console.log("FTS index created successfully.");
     }
     else {
         options.verbose && console.log("FTS index already exists.");
     }
-    return simpleTable;
 }

package/esm/methods/createPoints.d.ts

@@ -0,0 +1,5 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function createPoints(simpleTable: SimpleTable, latColumn: string, lonColumn: string, newColumn: string, options?: {
+    projection?: string;
+}): void;
+//# sourceMappingURL=createPoints.d.ts.map

package/esm/methods/createPoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPoints.d.ts","sourceRoot":"","sources":["../../src/methods/createPoints.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,QA0BtC"}

package/esm/methods/createPoints.js

@@ -0,0 +1,23 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import parseValue from "../helpers/parseValue.js";
+import queueOp from "../helpers/queueOp.js";
+export default function createPoints(simpleTable, latColumn, lonColumn, newColumn, options = {}) {
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "createPoints()",
+        parameters: { latColumn, lonColumn, newColumn, options },
+        needsSchema: true,
+        needsSpatial: true,
+        outputSchema: (types) => ({
+            ...types,
+            [newColumn]: `GEOMETRY('${options.projection ?? "EPSG:4326"}')`,
+        }),
+        buildSelect: (input, types) => {
+            const expression = `ST_Point(${quoteIdentifier(lonColumn)}, ${quoteIdentifier(latColumn)})::GEOMETRY(${parseValue(options.projection ?? "EPSG:4326")})`;
+            return Object.keys(types).includes(newColumn)
+                ? `SELECT * REPLACE (${expression} AS ${quoteIdentifier(newColumn)}) FROM ${input}`
+                : `SELECT *, ${expression} AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}

package/esm/methods/createVssIndex.d.ts

@@ -5,5 +5,5 @@ export default function createVssIndex(simpleTable: SimpleTable, column: string,
     efConstruction?: number;
     efSearch?: number;
     M?: number;
-}): Promise<SimpleTable>;
+}): void;
 //# sourceMappingURL=createVssIndex.d.ts.map

package/esm/methods/createVssIndex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createVssIndex.d.ts","sourceRoot":"","sources":["../../src/methods/createVssIndex.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,cAAc,CAC1C,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,CAAC,CAAC,EAAE,MAAM,CAAC;CACP,wBAyDP"}
+{"version":3,"file":"createVssIndex.d.ts","sourceRoot":"","sources":["../../src/methods/createVssIndex.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,CAAC,CAAC,EAAE,MAAM,CAAC;CACP,QAUP"}

package/esm/methods/createVssIndex.js

@@ -1,38 +1,59 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
 import camelCase from "../helpers/camelCase.js";
-export default async function createVssIndex(simpleTable, column, options = {}) {
+import queueOp from "../helpers/queueOp.js";
+import buildCreateIndexQuery from "../helpers/indexQueries.js";
+export default function createVssIndex(simpleTable, column, options = {}) {
+    // Index creation is multi-statement by nature: it executes as a barrier.
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "barrier",
+        method: "createVssIndex()",
+        parameters: { column, options },
+        execute: () => executeCreateVssIndex(simpleTable, column, options),
+    });
+}
+async function executeCreateVssIndex(simpleTable, column, options) {
     const indexName = `vss_cosine_index_${camelCase(simpleTable.name)}`;
-    const indexExists = simpleTable.indexes.includes(indexName);
+    const indexPosition = simpleTable.indexes.findIndex(({ name }) => name === indexName);
+    const indexExists = indexPosition >= 0;
     if (indexExists && options.overwrite) {
         options.verbose &&
-            console.log(`\nDropping existing VSS index on "${column}" column...`);
+            console.log(`\nDropping existing VSS index on ${quoteIdentifier(column)} column...`);
         await simpleTable.sdb.customQuery(`DROP INDEX IF EXISTS ${indexName};`);
         options.verbose && console.log("VSS index dropped.");
     }
     if (!indexExists || options.overwrite) {
         options.verbose &&
-            console.log(`\nCreating VSS index on "${column}" column...`);
-        // Build the WITH clause with all options
-        const withOptions = ["metric = 'cosine'"];
+            console.log(`\nCreating VSS index on ${quoteIdentifier(column)} column...`);
+        const indexOptions = {};
         if (options.efConstruction !== undefined) {
-            withOptions.push(`ef_construction = ${options.efConstruction}`);
+            indexOptions.efConstruction = options.efConstruction;
         }
         if (options.efSearch !== undefined) {
-            withOptions.push(`ef_search = ${options.efSearch}`);
+            indexOptions.efSearch = options.efSearch;
         }
         if (options.M !== undefined) {
-            withOptions.push(`M = ${options.M}`);
+            indexOptions.M = options.M;
         }
+        const definition = {
+            kind: "vss",
+            name: indexName,
+            column,
+            options: indexOptions,
+        };
         await simpleTable.sdb.customQuery(`INSTALL vss; LOAD vss;${simpleTable.sdb.file !== ":memory:"
             ? "\nSET hnsw_enable_experimental_persistence=true;"
             : ""}
-    CREATE INDEX ${indexName} ON "${simpleTable.name}" USING HNSW ("${column}") WITH (${withOptions.join(", ")});`);
-        if (!simpleTable.indexes.includes(indexName)) {
-            simpleTable.indexes.push(indexName);
+      ${buildCreateIndexQuery(simpleTable.name, definition)}`);
+        if (indexExists) {
+            simpleTable.indexes[indexPosition] = definition;
+        }
+        else {
+            simpleTable.indexes.push(definition);
         }
         options.verbose && console.log("VSS index created successfully.");
     }
     else {
         options.verbose && console.log("VSS index already exists.");
     }
-    return simpleTable;
 }

package/esm/methods/crossJoin.d.ts

@@ -0,0 +1,5 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function crossJoin(simpleTable: SimpleTable, rightTable: SimpleTable, options?: {
+    outputTable?: string | boolean;
+}): SimpleTable;
+//# sourceMappingURL=crossJoin.d.ts.map

package/esm/methods/crossJoin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crossJoin.d.ts","sourceRoot":"","sources":["../../src/methods/crossJoin.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,WAAW,EACvB,OAAO,GAAE;IACP,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,GACL,WAAW,CAmBb"}

package/esm/methods/crossJoin.js

@@ -0,0 +1,35 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import getIdenticalColumns from "../helpers/getIdenticalColumns.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import queueOp from "../helpers/queueOp.js";
+import resolveOutputTable from "../helpers/resolveOutputTable.js";
+import assertSameDatabase from "../helpers/assertSameDatabase.js";
+export default function crossJoin(simpleTable, rightTable, options = {}) {
+    assertSameDatabase(simpleTable.sdb, [rightTable], "crossJoin()");
+    options = structuredClone(options);
+    options.outputTable = resolveOutputTable(simpleTable, options.outputTable);
+    // The output table instance is created at call time so it can be returned
+    // synchronously and chained on right away.
+    const outputTable = typeof options.outputTable === "string"
+        ? simpleTable.sdb.newTable(options.outputTable)
+        : simpleTable;
+    queueOp(outputTable, {
+        kind: "barrier",
+        method: "crossJoin()",
+        parameters: { rightTable: rightTable.name, options },
+        execute: () => executeCrossJoin(simpleTable, rightTable, outputTable),
+    });
+    return outputTable;
+}
+async function executeCrossJoin(simpleTable, rightTable, outputTable) {
+    const identicalColumns = getIdenticalColumns(await simpleTable.getColumns(), await rightTable.getColumns());
+    if (identicalColumns.length > 0) {
+        throw new Error(`The tables have columns with identical names. Rename or remove ${identicalColumns.map((d) => `${quoteIdentifier(d)}`).join(", ")} in one of the two tables before doing the cross join.`);
+    }
+    await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable.name)} AS SELECT ${quoteIdentifier(simpleTable.name)}.*, ${quoteIdentifier(rightTable.name)}.* FROM ${quoteIdentifier(simpleTable.name)} CROSS JOIN ${quoteIdentifier(rightTable.name)};`, mergeOptions(simpleTable, {
+        table: outputTable.name,
+        method: "crossJoin()",
+        parameters: { rightTable: rightTable.name },
+    }));
+}

package/esm/methods/difference.d.ts

@@ -0,0 +1,3 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function difference(simpleTable: SimpleTable, column1: string, column2: string, newColumn: string): void;
+//# sourceMappingURL=difference.d.ts.map

package/esm/methods/difference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"difference.d.ts","sourceRoot":"","sources":["../../src/methods/difference.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,QAuBlB"}

package/esm/methods/difference.js

@@ -0,0 +1,19 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import queueOp from "../helpers/queueOp.js";
+export default function difference(simpleTable, column1, column2, newColumn) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "difference()",
+        parameters: { column1, column2, newColumn },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            // The schema type carries the projection (e.g. GEOMETRY('EPSG:4326')),
+            // so the cast keeps it on the new geometries.
+            const expression = `ST_Difference(${quoteIdentifier(column1)}, ${quoteIdentifier(column2)})::${types[column1]}`;
+            return Object.keys(types).includes(newColumn)
+                ? `SELECT * REPLACE (${expression} AS ${quoteIdentifier(newColumn)}) FROM ${input}`
+                : `SELECT *, ${expression} AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}

package/esm/methods/distance.d.ts

@@ -0,0 +1,7 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function distance(simpleTable: SimpleTable, column1: string, column2: string, newColumn: string, options?: {
+    unit?: "m" | "km";
+    method?: "srs" | "haversine" | "spheroid";
+    decimals?: number;
+}): void;
+//# sourceMappingURL=distance.d.ts.map

package/esm/methods/distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distance.d.ts","sourceRoot":"","sources":["../../src/methods/distance.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IAClB,MAAM,CAAC,EAAE,KAAK,GAAG,WAAW,GAAG,UAAU,CAAC;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACd,QAmBP"}