@nshiab/simple-data-analysis-core 1.0.1 → 2.0.1

package/esm/methods/join.js

@@ -1,57 +1,106 @@
+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 joinQuery from "./joinQuery.js";
-export default async function join(leftTable, rightTable, options = {}) {
+import queueOp from "../helpers/queueOp.js";
+import assertSameDatabase from "../helpers/assertSameDatabase.js";
+export default function join(leftTable, rightTable, options = {}) {
+    assertSameDatabase(leftTable.sdb, [rightTable], "join()");
+    options = structuredClone(options);
+    // 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"
+        ? leftTable.sdb.newTable(options.outputTable)
+        : leftTable;
+    queueOp(outputTable, {
+        kind: "barrier",
+        method: "join()",
+        parameters: { rightTable: rightTable.name, options },
+        execute: () => executeJoin(leftTable, rightTable, outputTable, options),
+    });
+    return outputTable;
+}
+async function executeJoin(leftTable, rightTable, outputTable, options) {
     const leftTableColumns = await leftTable.getColumns();
     const rightTableColumns = await rightTable.getColumns();
     const identicalColumns = getIdenticalColumns(leftTableColumns, rightTableColumns);
-    let commonColumn;
-    if (typeof options.commonColumn === "string") {
-        commonColumn = [options.commonColumn];
+    let on;
+    if (typeof options.on === "string") {
+        on = [options.on];
     }
-    else if (Array.isArray(options.commonColumn)) {
-        commonColumn = options.commonColumn;
+    else if (Array.isArray(options.on)) {
+        on = options.on;
     }
     else {
         if (identicalColumns.length === 0) {
-            throw new Error("No common column");
+            throw new Error(`join() cannot infer a join column because tables ${quoteIdentifier(leftTable.name)} and ${quoteIdentifier(rightTable.name)} have no columns in common. Pass { on: "column" } after ensuring that column exists in both tables.`);
         }
         else if (identicalColumns.length === 1) {
-            commonColumn = identicalColumns;
+            on = identicalColumns;
         }
         else {
-            throw new Error("Multiple columns with identical names in the tables. You need to pick the ones you want.");
+            throw new Error(`join() found ${identicalColumns.length} possible join columns shared by tables ${quoteIdentifier(leftTable.name)} and ${quoteIdentifier(rightTable.name)}: ${identicalColumns.map(quoteIdentifier).join(", ")}. Pass { on: "column" } or { on: ["column1", "column2"] } to choose.`);
         }
     }
-    const identicalColumnsForError = identicalColumns.filter((d) => !commonColumn.includes(d));
+    const identicalColumnsForError = identicalColumns.filter((d) => !on.includes(d));
     if (identicalColumnsForError.length > 0) {
         if (identicalColumnsForError.length === 1) {
-            throw new Error(`The tables have columns with identical names (excluding ${commonColumn.map((d) => `"${d}"`).join(", ")} used for the join). Rename or remove ${identicalColumnsForError.map((d) => `"${d}"`).join(", ")} in one of the two tables before doing the join. If relevant, you can also add it to the commonColumn option.`);
+            throw new Error(`The tables have columns with identical names (excluding ${on.map((d) => `${quoteIdentifier(d)}`).join(", ")} used for the join). Rename or remove ${identicalColumnsForError.map((d) => `${quoteIdentifier(d)}`).join(", ")} in one of the two tables before doing the join. If relevant, you can also add it to the on option.`);
         }
         else {
-            throw new Error(`The tables have columns with identical names (excluding ${commonColumn.map((d) => `"${d}"`).join(", ")} used for the join). Rename or remove ${identicalColumnsForError.map((d) => `"${d}"`).join(", ")} in one of the two tables before doing the join. If relevant, you can also add them to the commonColumn option.`);
+            throw new Error(`The tables have columns with identical names (excluding ${on.map((d) => `${quoteIdentifier(d)}`).join(", ")} used for the join). Rename or remove ${identicalColumnsForError.map((d) => `${quoteIdentifier(d)}`).join(", ")} in one of the two tables before doing the join. If relevant, you can also add them to the on option.`);
         }
     }
-    await queryDB(leftTable, joinQuery(leftTable.name, rightTable.name, commonColumn, options.type ?? "left", typeof options.outputTable === "string"
-        ? options.outputTable
-        : leftTable.name), mergeOptions(leftTable, {
-        table: typeof options.outputTable === "string"
-            ? options.outputTable
-            : leftTable.name,
+    // The right table's copies of the join columns are excluded from the
+    // SELECT directly, instead of dropping them with a rewrite after the join.
+    // The join columns come from the side that has a value for every row of
+    // the result: the left table for inner and left joins, the right table for
+    // right joins, and whichever side matched for full joins.
+    const type = options.type ?? "left";
+    const joinColumn = (d) => {
+        if (type === "right") {
+            return `${quoteIdentifier(rightTable.name)}.${quoteIdentifier(d)} AS ${quoteIdentifier(d)}`;
+        }
+        if (type === "full") {
+            return `COALESCE(${quoteIdentifier(leftTable.name)}.${quoteIdentifier(d)}, ${quoteIdentifier(rightTable.name)}.${quoteIdentifier(d)}) AS ${quoteIdentifier(d)}`;
+        }
+        return `${quoteIdentifier(leftTable.name)}.${quoteIdentifier(d)}`;
+    };
+    const selectList = [
+        ...leftTableColumns.map((d) => on.includes(d)
+            ? joinColumn(d)
+            : `${quoteIdentifier(leftTable.name)}.${quoteIdentifier(d)}`),
+        ...rightTableColumns
+            .filter((d) => !on.includes(d))
+            .map((d) => `${quoteIdentifier(rightTable.name)}.${quoteIdentifier(d)}`),
+    ].join(", ");
+    await queryDB(leftTable, joinQuery(leftTable.name, rightTable.name, on, type, outputTable.name, selectList), mergeOptions(leftTable, {
+        table: outputTable.name,
         method: "join()",
         parameters: {
-            rightTable,
+            rightTable: rightTable.name,
             options,
         },
     }));
-    const outputTable = typeof options.outputTable === "string"
-        ? leftTable.sdb.newTable(options.outputTable)
-        : leftTable;
-    const columns = await outputTable.getColumns();
-    const extraCommonColumns = columns.filter((d) => commonColumn.map((c) => `${c}_1`).includes(d));
-    if (extraCommonColumns.length > 0) {
-        await outputTable.removeColumns(extraCommonColumns);
+}
+function joinQuery(leftTable, rightTable, on, join, outputTable, selectList) {
+    let query = `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable)} AS SELECT ${selectList}`;
+    if (join === "inner") {
+        query += ` FROM ${quoteIdentifier(leftTable)} JOIN ${quoteIdentifier(rightTable)}`;
     }
-    return outputTable;
+    else if (join === "left") {
+        query += ` FROM ${quoteIdentifier(leftTable)} LEFT JOIN ${quoteIdentifier(rightTable)}`;
+    }
+    else if (join === "right") {
+        query += ` FROM ${quoteIdentifier(leftTable)} RIGHT JOIN ${quoteIdentifier(rightTable)}`;
+    }
+    else if (join === "full") {
+        query += ` FROM ${quoteIdentifier(leftTable)} FULL JOIN ${quoteIdentifier(rightTable)}`;
+    }
+    else {
+        throw new Error(`Unknown ${join} join.`);
+    }
+    query += ` ON (${on.map((d) => `${quoteIdentifier(leftTable)}.${quoteIdentifier(d)} = ${quoteIdentifier(rightTable)}.${quoteIdentifier(d)}`)
+        .join(" AND ")});\n`;
+    return query;
 }

package/esm/methods/joinGeo.d.ts

@@ -1,10 +1,12 @@
 import type SimpleTable from "../class/SimpleTable.js";
-export default function joinGeo(leftTable: SimpleTable, method: "intersect" | "inside" | "within", rightTable: SimpleTable, options?: {
-    leftTableColumn?: string;
-    rightTableColumn?: string;
+export default function joinGeo(leftTable: SimpleTable, method: "intersect" | "inside" | "withinDistance", rightTable: SimpleTable, options?: {
+    leftColumn?: string;
+    rightColumn?: string;
     type?: "inner" | "left" | "right" | "full";
     distance?: number;
     distanceMethod?: "srs" | "haversine" | "spheroid";
+    excludeLeftGeometry?: boolean;
+    excludeRightGeometry?: boolean;
     outputTable?: string | boolean;
-}): Promise<SimpleTable>;
+}): SimpleTable;
 //# sourceMappingURL=joinGeo.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"joinGeo.d.ts","sourceRoot":"","sources":["../../src/methods/joinGeo.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAOvD,wBAA8B,OAAO,CACnC,SAAS,EAAE,WAAW,EACtB,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,EACzC,UAAU,EAAE,WAAW,EACvB,OAAO,GAAE;IACP,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,KAAK,GAAG,WAAW,GAAG,UAAU,CAAC;IAClD,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,wBA4FP"}
+{"version":3,"file":"joinGeo.d.ts","sourceRoot":"","sources":["../../src/methods/joinGeo.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAQvD,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,SAAS,EAAE,WAAW,EACtB,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,gBAAgB,EACjD,UAAU,EAAE,WAAW,EACvB,OAAO,GAAE;IACP,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,KAAK,GAAG,WAAW,GAAG,UAAU,CAAC;IAClD,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,GACL,WAAW,CAmBb"}

package/esm/methods/joinGeo.js

@@ -1,42 +1,90 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
 import capitalize from "../helpers/capitalize.js";
-import findGeoColumn from "../helpers/findGeoColumn.js";
+import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
 import getIdenticalColumns from "../helpers/getIdenticalColumns.js";
 import mergeOptions from "../helpers/mergeOptions.js";
 import queryDB from "../helpers/queryDB.js";
-import joinGeoQuery from "./joinGeoQuery.js";
-export default async function joinGeo(leftTable, method, rightTable, options = {}) {
-    const leftTableColumn = options.leftTableColumn ??
-        (await findGeoColumn(leftTable));
-    const rightTableColumn = options.rightTableColumn ??
-        (await findGeoColumn(rightTable));
-    const commonColumn = leftTableColumn === rightTableColumn
-        ? leftTableColumn
-        : "";
-    const identicalColumns = (getIdenticalColumns(await leftTable.getColumns(), await rightTable.getColumns())).filter((d) => d !== commonColumn);
+import queueOp from "../helpers/queueOp.js";
+import assertSameDatabase from "../helpers/assertSameDatabase.js";
+export default function joinGeo(leftTable, method, rightTable, options = {}) {
+    assertSameDatabase(leftTable.sdb, [rightTable], "joinGeo()");
+    options = structuredClone(options);
+    validateJoinGeoOptions(method, options);
+    // 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"
+        ? leftTable.sdb.newTable(options.outputTable)
+        : leftTable;
+    queueOp(outputTable, {
+        kind: "barrier",
+        method: "joinGeo()",
+        parameters: { method, rightTable: rightTable.name, options },
+        execute: () => executeJoinGeo(leftTable, method, rightTable, outputTable, options),
+    });
+    return outputTable;
+}
+function validateJoinGeoOptions(method, options) {
+    if (!["intersect", "inside", "withinDistance"].includes(method)) {
+        throw new Error(`joinGeo() method must be "intersect", "inside", or "withinDistance". Received ${formatReceivedValue(method)}.`);
+    }
+    if (options.type !== undefined &&
+        !["inner", "left", "right", "full"].includes(options.type)) {
+        throw new Error(`joinGeo() options.type must be "inner", "left", "right", or "full". Received ${formatReceivedValue(options.type)}.`);
+    }
+    if (options.distanceMethod !== undefined &&
+        !["srs", "haversine", "spheroid"].includes(options.distanceMethod)) {
+        throw new Error(`joinGeo() options.distanceMethod must be "srs", "haversine", or "spheroid". Received ${formatReceivedValue(options.distanceMethod)}.`);
+    }
+    if (method === "withinDistance" &&
+        (typeof options.distance !== "number" || !Number.isFinite(options.distance))) {
+        throw new Error(`joinGeo() options.distance must be a finite number when method is "withinDistance". Received ${formatReceivedValue(options.distance)}.`);
+    }
+}
+function formatReceivedValue(value) {
+    return JSON.stringify(value) ?? String(value);
+}
+async function executeJoinGeo(leftTable, method, rightTable, outputTable, options) {
+    const leftTypes = await leftTable.getTypes();
+    const rightTypes = await rightTable.getTypes();
+    const leftColumn = options.leftColumn ??
+        findGeoColumnFromSchema(leftTypes, "joinGeo()", leftTable.name);
+    const rightColumn = options.rightColumn ??
+        findGeoColumnFromSchema(rightTypes, "joinGeo()", rightTable.name);
+    const leftTableColumns = Object.keys(leftTypes);
+    const rightTableColumns = Object.keys(rightTypes);
+    const sharedColumn = leftColumn === rightColumn ? leftColumn : "";
+    const identicalColumns = (getIdenticalColumns(leftTableColumns, rightTableColumns)).filter((d) => d !== sharedColumn);
     if (identicalColumns.length > 0) {
-        throw new Error(`The tables have columns with identical names ${commonColumn !== ""
-            ? `(excluding the columns "${commonColumn}" used for the geospatial join)`
-            : ""}. Rename or remove ${identicalColumns.map((d) => `"${d}"`).join(", ")} in one of the two tables before doing the join.`);
-    }
-    let leftTableColumnForQuery = leftTableColumn;
-    let rightTableColumnForQuery = rightTableColumn;
-    // We change the column names for geometries
-    if (leftTableColumn === rightTableColumn) {
-        leftTableColumnForQuery = `${leftTableColumn}${capitalize(leftTable.name)}`;
-        const leftObj = {};
-        leftObj[leftTableColumn] = leftTableColumnForQuery;
-        await leftTable.renameColumns(leftObj);
-        rightTableColumnForQuery = `${rightTableColumn}${capitalize(rightTable.name)}`;
-        const rightObj = {};
-        rightObj[rightTableColumn] = rightTableColumnForQuery;
-        await rightTable.renameColumns(rightObj);
+        throw new Error(`The tables have columns with identical names ${sharedColumn !== ""
+            ? `(excluding the columns ${quoteIdentifier(sharedColumn)} used for the geospatial join)`
+            : ""}. Rename or remove ${identicalColumns.map((d) => `${quoteIdentifier(d)}`).join(", ")} in one of the two tables before doing the join.`);
+    }
+    const excludeLeftGeometry = options.excludeLeftGeometry ?? false;
+    const excludeRightGeometry = options.excludeRightGeometry ?? false;
+    const retainSharedGeometries = sharedColumn !== "" &&
+        !excludeLeftGeometry && !excludeRightGeometry;
+    const rightGeometryOutputColumn = retainSharedGeometries
+        ? `${rightColumn}${capitalize(rightTable.name)}`
+        : undefined;
+    if (rightGeometryOutputColumn !== undefined &&
+        [...leftTableColumns, ...rightTableColumns]
+            .filter((column) => column !== rightColumn)
+            .includes(rightGeometryOutputColumn)) {
+        throw new Error(`Cannot name the right geometry column ${quoteIdentifier(rightGeometryOutputColumn)} because a column with that name already exists. Rename the existing ${quoteIdentifier(rightGeometryOutputColumn)} column before calling joinGeo(), or call joinGeo() with { excludeRightGeometry: true }.`);
     }
+    const leftSelect = `${quoteIdentifier(leftTable.name)}.*${excludeLeftGeometry ? ` EXCLUDE (${quoteIdentifier(leftColumn)})` : ""}`;
+    const excludeRightFromStar = excludeRightGeometry || retainSharedGeometries;
+    const rightSelect = `${quoteIdentifier(rightTable.name)}.*${excludeRightFromStar ? ` EXCLUDE (${quoteIdentifier(rightColumn)})` : ""}`;
+    const selectList = [
+        leftSelect,
+        rightSelect,
+        ...(rightGeometryOutputColumn === undefined ? [] : [
+            `${quoteIdentifier(rightTable.name)}.${quoteIdentifier(rightColumn)} AS ${quoteIdentifier(rightGeometryOutputColumn)}`,
+        ]),
+    ].join(", ");
     const type = options.type ?? "left";
-    const outputTable = typeof options.outputTable === "string"
-        ? options.outputTable
-        : leftTable.name;
-    await queryDB(leftTable, joinGeoQuery(leftTable.name, leftTableColumnForQuery, method, rightTable.name, rightTableColumnForQuery, type, outputTable, options.distance, options.distanceMethod), mergeOptions(leftTable, {
-        table: outputTable,
+    await queryDB(leftTable, joinGeoQuery(leftTable.name, leftColumn, method, rightTable.name, rightColumn, type, outputTable.name, selectList, options.distance, options.distanceMethod), mergeOptions(leftTable, {
+        table: outputTable.name,
         method: "joinGeo()",
         parameters: {
             leftTable: leftTable.name,
@@ -45,19 +93,54 @@ export default async function joinGeo(leftTable, method, rightTable, options = {
             options,
         },
     }));
-    // We bring back the column names for geometries
-    if (leftTableColumn === rightTableColumn) {
-        const leftObj = {};
-        leftObj[leftTableColumnForQuery] = leftTableColumn;
-        await leftTable.renameColumns(leftObj);
-        const rightObj = {};
-        rightObj[rightTableColumnForQuery] = rightTableColumn;
-        await rightTable.renameColumns(rightObj);
-    }
-    if (typeof options.outputTable === "string") {
-        return leftTable.sdb.newTable(options.outputTable);
+}
+function joinGeoQuery(leftTable, leftColumn, method, rightTable, rightColumn, join, outputTable, selectList, distance, distanceMethod) {
+    let query = `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable)} AS SELECT ${selectList}`;
+    if (join === "inner") {
+        query += ` FROM ${quoteIdentifier(leftTable)} JOIN ${quoteIdentifier(rightTable)}`;
+    }
+    else if (join === "left") {
+        query += ` FROM ${quoteIdentifier(leftTable)} LEFT JOIN ${quoteIdentifier(rightTable)}`;
+    }
+    else if (join === "right") {
+        query += ` FROM ${quoteIdentifier(leftTable)} RIGHT JOIN ${quoteIdentifier(rightTable)}`;
+    }
+    else if (join === "full") {
+        query += ` FROM ${quoteIdentifier(leftTable)} FULL JOIN ${quoteIdentifier(rightTable)}`;
+    }
+    else {
+        throw new Error(`Unknown ${join} join.`);
+    }
+    if (method === "intersect") {
+        query += ` ON ST_Intersects(${quoteIdentifier(leftTable)}.${quoteIdentifier(leftColumn)}, ${quoteIdentifier(rightTable)}.${quoteIdentifier(rightColumn)});`;
+    }
+    else if (method === "inside") {
+        // Order is important
+        query += ` ON ST_Covers(${quoteIdentifier(rightTable)}.${quoteIdentifier(rightColumn)}, ${quoteIdentifier(leftTable)}.${quoteIdentifier(leftColumn)});`;
+    }
+    else if (method === "withinDistance") {
+        if (typeof distance === "number") {
+            if (distanceMethod === undefined || distanceMethod === "srs") {
+                query += ` ON ST_DWithin(${quoteIdentifier(leftTable)}.${quoteIdentifier(leftColumn)}, ${quoteIdentifier(rightTable)}.${quoteIdentifier(rightColumn)}, ${distance})`;
+            }
+            else if (distanceMethod === "haversine") {
+                // Maybe ST_DWithin_Sphere will be available soon?
+                query += ` ON ST_Distance_Sphere(${quoteIdentifier(leftTable)}.${quoteIdentifier(leftColumn)}, ${quoteIdentifier(rightTable)}.${quoteIdentifier(rightColumn)}) < ${distance}`;
+            }
+            else if (distanceMethod === "spheroid") {
+                // Should be using ST_DWithin_Spheroid but doesn't work?
+                query += ` ON ST_Distance_Spheroid(${quoteIdentifier(leftTable)}.${quoteIdentifier(leftColumn)}::GEOMETRY, ${quoteIdentifier(rightTable)}.${quoteIdentifier(rightColumn)}::GEOMETRY) < ${distance}`;
+            }
+            else {
+                throw new Error(`Unknown ${distanceMethod}`);
+            }
+        }
+        else {
+            throw new Error("options.distance must be a number");
+        }
     }
     else {
-        return leftTable;
+        throw new Error(`Unknown ${method} method`);
     }
+    return query;
 }

package/esm/methods/keepValues.d.ts

@@ -0,0 +1,5 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function keepValues(simpleTable: SimpleTable, columnsAndValues: {
+    [key: string]: unknown;
+}): void;
+//# sourceMappingURL=keepValues.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keepValues.d.ts","sourceRoot":"","sources":["../../src/methods/keepValues.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,WAAW,EAAE,WAAW,EACxB,gBAAgB,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,QAiB7C"}

package/esm/methods/keepValues.js

@@ -0,0 +1,35 @@
+import queueOp from "../helpers/queueOp.js";
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import prepareValueFilters from "../helpers/prepareValueFilters.js";
+export default function keepValues(simpleTable, columnsAndValues) {
+    const captured = Object.fromEntries(Object.entries(columnsAndValues).map(([column, values]) => [
+        column,
+        Array.isArray(values) ? [...values] : values,
+    ]));
+    const filters = prepareValueFilters(captured);
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "keepValues()",
+        parameters: { columnsAndValues: captured },
+        values: filters.flatMap((filter) => filter.values),
+        needsSchema: false,
+        buildSelect: (input) => keepValuesSelect(input, filters),
+    });
+}
+function keepValuesSelect(input, filters) {
+    let query = `SELECT * FROM ${input} WHERE\n`;
+    const conditions = [];
+    for (const filter of filters) {
+        const column = quoteIdentifier(filter.column);
+        const inValues = filter.values.length > 0
+            ? `${column} IN (${filter.values.map(() => "?").join(", ")})`
+            : null;
+        conditions.push(inValues === null
+            ? filter.includesNull ? `${column} IS NULL` : "FALSE"
+            : filter.includesNull
+                ? `(${inValues} OR ${column} IS NULL)`
+                : inValues);
+    }
+    query += conditions.join("\nAND ");
+    return query;
+}

package/esm/methods/lastChars.d.ts

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

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

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

package/esm/methods/lastChars.js

@@ -0,0 +1,11 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import queueOp from "../helpers/queueOp.js";
+export default function lastChars(simpleTable, column, count) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "lastChars()",
+        parameters: { column, count },
+        needsSchema: false,
+        buildSelect: (input) => `SELECT * REPLACE (RIGHT(${quoteIdentifier(column)}, ${count}) AS ${quoteIdentifier(column)}) FROM ${input}`,
+    });
+}

package/esm/methods/length.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"length.d.ts","sourceRoot":"","sources":["../../src/methods/length.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,MAAM,CAC5B,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,QAyBxE"}

package/esm/methods/length.js

@@ -0,0 +1,25 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import assertNewColumns from "../helpers/assertNewColumns.js";
+import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
+import queueOp from "../helpers/queueOp.js";
+export default function length(simpleTable, newColumn, options = {}) {
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "length()",
+        parameters: { newColumn, options },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            assertNewColumns(types, [newColumn], "length()");
+            const column = typeof options.column === "string"
+                ? options.column
+                : findGeoColumnFromSchema(types, "length()", simpleTable.name);
+            let expression = `ST_Length_Spheroid(${quoteIdentifier(column)}) ${options.unit === "km" ? "/ 1000" : ""}`;
+            if (typeof options.decimals === "number") {
+                expression = `ROUND(${expression}, ${options.decimals})`;
+            }
+            return `SELECT *, CAST(${expression} AS DOUBLE) AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}

package/esm/methods/linearRegressions.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"linearRegressions.d.ts","sourceRoot":"","sources":["../../src/methods/linearRegressions.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,iBAAiB,CAC7C,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,iBA8CP"}
+{"version":3,"file":"linearRegressions.d.ts","sourceRoot":"","sources":["../../src/methods/linearRegressions.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,MAAM,CAAC,OAAO,UAAU,iBAAiB,CACvC,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/linearRegressions.js

@@ -1,43 +1,97 @@
+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 linearRegressionQuery from "./linearRegressionQuery.js";
-export default async function linearRegressions(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 linearRegressions(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: "linearRegressions()",
+            parameters: { options },
+            execute: async () => {
+                const permutations = getLinearRegressionsPermutations(await simpleTable.getTypes(), options, simpleTable.name);
+                await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable.name)} AS ${linearRegressionsSelect(`${quoteIdentifier(simpleTable.name)}`, permutations, options)}`, mergeOptions(simpleTable, {
+                    table: outputTable.name,
+                    method: "linearRegressions()",
+                    parameters: {
+                        options,
+                        "permutations (computed)": permutations,
+                    },
+                    values: linearRegressionsValues(permutations),
+                }));
+            },
+        });
+        return outputTable;
+    }
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "linearRegressions()",
+        parameters: { options },
+        needsSchema: true,
+        values: (types) => linearRegressionsValues(getLinearRegressionsPermutations(types, options, simpleTable.name)),
+        buildSelect: (input, types) => linearRegressionsSelect(input, getLinearRegressionsPermutations(types, options, simpleTable.name), options),
+    });
+    return simpleTable;
+}
+function linearRegressionsValues(permutations) {
+    return permutations.flatMap(([x, y]) => [x, y]);
+}
+function getLinearRegressionsPermutations(types, options, tableName) {
+    const columns = validateNumericalAnalysis(types, options, "linearRegressions()", tableName);
     const permutations = [];
-    if (!options.x && !options.y) {
-        const types = await SimpleTable.getTypes();
-        const columns = keepNumericalColumns(types);
+    if (options.x === undefined) {
         const combinations = getCombinations(columns, 2);
         for (const c of combinations) {
             permutations.push(c);
             permutations.push([c[1], c[0]]);
         }
     }
-    else if (options.x && !options.y) {
-        const types = await SimpleTable.getTypes();
-        const columns = keepNumericalColumns(types);
+    else if (options.y === undefined) {
         for (const col of columns) {
             if (col !== options.x) {
                 permutations.push([options.x, col]);
             }
         }
     }
-    else if (options.x && options.y) {
-        permutations.push([options.x, options.y]);
-    }
     else {
-        throw new Error("No combinations of x and y");
+        permutations.push([options.x, options.y]);
     }
-    await queryDB(SimpleTable, linearRegressionQuery(SimpleTable.name, outputTable, permutations, options), mergeOptions(SimpleTable, {
-        table: outputTable,
-        method: "linearRegressions()",
-        parameters: {
-            options,
-            "permutations (computed)": permutations,
-        },
-    }));
+    return permutations;
+}
+function linearRegressionsSelect(input, permutations, 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 permutation (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 = permutations.map((perm) => {
+        const expressions = [
+            ["slope", "REGR_SLOPE"],
+            ["yIntercept", "REGR_INTERCEPT"],
+            ["r2", "REGR_R2"],
+        ].map(([alias, fn]) => {
+            const expression = typeof options.decimals === "number"
+                ? `ROUND(${fn}(${quoteIdentifier(perm[1])}, ${quoteIdentifier(perm[0])}), ${options.decimals})`
+                : `${fn}(${quoteIdentifier(perm[1])}, ${quoteIdentifier(perm[0])})`;
+            return `${expression} AS ${quoteIdentifier(alias)}`;
+        });
+        return `SELECT ${catSelect}? AS ${quoteIdentifier("x")}, ? AS ${quoteIdentifier("y")}, ${expressions.join(", ")}
+        FROM ${input}${groupBy}`;
+    });
+    return branches.join("\nUNION ALL\n");
 }

package/esm/methods/linesToPolygons.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"linesToPolygons.d.ts","sourceRoot":"","sources":["../../src/methods/linesToPolygons.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,WAAW,EAAE,WAAW,EACxB,MAAM,CAAC,EAAE,MAAM,QAgBhB"}

package/esm/methods/linesToPolygons.js

@@ -0,0 +1,17 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
+import queueOp from "../helpers/queueOp.js";
+export default function linesToPolygons(simpleTable, column) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "linesToPolygons()",
+        parameters: { column },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            const col = column ??
+                findGeoColumnFromSchema(types, "linesToPolygons()", simpleTable.name);
+            return `SELECT * EXCLUDE(${quoteIdentifier(col)}), ST_MakePolygon(${quoteIdentifier(col)}) as ${quoteIdentifier(col)} FROM ${input}`;
+        },
+    });
+}