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

package/script/methods/splitExtract.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = splitExtract;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const assertNewColumns_js_1 = __importDefault(require("../helpers/assertNewColumns.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function splitExtract(simpleTable, column, separator, index, newColumn) {
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "splitExtract()",
+        parameters: { column, separator, index, newColumn },
+        values: [separator],
+        needsSchema: true,
+        buildSelect: (input, types) => {
+            // Writing back to the split column itself is allowed (in-place); any
+            // other existing column is a duplicate, like v1's ALTER TABLE ADD.
+            (0, assertNewColumns_js_1.default)(types, [newColumn], "splitExtract()", [column]);
+            const expression = `SPLIT_PART(${(0, quoteIdentifier_js_1.default)(column)}, ?, ${index + 1})`;
+            return column === newColumn
+                ? `SELECT * REPLACE (${expression} AS ${(0, quoteIdentifier_js_1.default)(newColumn)}) FROM ${input}`
+                : `SELECT *, ${expression} AS ${(0, quoteIdentifier_js_1.default)(newColumn)} FROM ${input}`;
+        },
+    });
+}

package/script/methods/splitSpread.d.ts

@@ -1,5 +1,5 @@
 import type SimpleTable from "../class/SimpleTable.js";
 export default function splitSpread(simpleTable: SimpleTable, column: string, separator: string, newColumns: string[], options?: {
-    noCheck?: boolean;
-}): Promise<void>;
+    strict?: boolean;
+}): void;
 //# sourceMappingURL=splitSpread.d.ts.map

package/script/methods/splitSpread.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"splitSpread.d.ts","sourceRoot":"","sources":["../../src/methods/splitSpread.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,WAAW,CACvC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,GAAE;IACP,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,iBAiGP"}
+{"version":3,"file":"splitSpread.d.ts","sourceRoot":"","sources":["../../src/methods/splitSpread.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,OAAO,CAAC;CACb,QAkBP"}

package/script/methods/splitSpread.js

@@ -4,64 +4,87 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = splitSpread;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const assertNewColumns_js_1 = __importDefault(require("../helpers/assertNewColumns.js"));
 const mergeOptions_js_1 = __importDefault(require("../helpers/mergeOptions.js"));
 const queryDB_js_1 = __importDefault(require("../helpers/queryDB.js"));
-async function splitSpread(simpleTable, column, separator, newColumns, options = {}) {
-    const nbParts = newColumns.length;
-    if (!options.noCheck) {
-        // Check if any row has more parts than expected
-        const maxPartsResult = await (0, queryDB_js_1.default)(simpleTable, `SELECT MAX(ARRAY_LENGTH(STRING_SPLIT("${column}", '${separator}'))) as max_parts FROM "${simpleTable.name}"`, (0, mergeOptions_js_1.default)(simpleTable, {
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function splitSpread(simpleTable, column, separator, newColumns, options = {}) {
+    newColumns = [...newColumns];
+    if (newColumns.length === 0) {
+        throw new Error("splitSpread() newColumns must contain at least one column.");
+    }
+    options = structuredClone(options);
+    // The pre-validation queries the data, so splitSpread can't be expressed
+    // as a single SELECT over its input: it executes as a barrier.
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "barrier",
+        method: "splitSpread()",
+        parameters: { column, separator, newColumns, options },
+        execute: () => executeSplitSpread(simpleTable, column, separator, newColumns, options),
+    });
+}
+async function executeSplitSpread(simpleTable, column, separator, newColumns, options) {
+    const partCount = newColumns.length;
+    const strict = options.strict !== false;
+    // A SELECT *, expr AS col colliding with an existing column would be
+    // silently renamed by DuckDB (col -> col_1) instead of erroring, unlike
+    // the ALTER TABLE ADD this used to run.
+    (0, assertNewColumns_js_1.default)(await simpleTable.getTypes(), newColumns, "splitSpread()");
+    if (strict) {
+        // Both bounds come from the same scan instead of one query each.
+        const partsResult = await (0, queryDB_js_1.default)(simpleTable, `SELECT
+        MAX(ARRAY_LENGTH(STRING_SPLIT(${(0, quoteIdentifier_js_1.default)(column)}, ?))) AS max_parts,
+        MIN(ARRAY_LENGTH(STRING_SPLIT(${(0, quoteIdentifier_js_1.default)(column)}, ?))) AS min_parts
+      FROM ${(0, quoteIdentifier_js_1.default)(simpleTable.name)}`, (0, mergeOptions_js_1.default)(simpleTable, {
             table: simpleTable.name,
             method: "splitSpread()",
             parameters: { column, separator, newColumns },
-            returnDataFrom: "query",
+            returnData: true,
+            values: [separator, separator],
         }));
-        if (maxPartsResult && maxPartsResult.length > 0) {
-            const maxParts = maxPartsResult[0].max_parts;
-            if (maxParts > nbParts) {
+        if (partsResult && partsResult.length > 0) {
+            const maxParts = partsResult[0].max_parts;
+            const minParts = partsResult[0].min_parts;
+            if (maxParts > partCount) {
                 // Get the first 5 rows with more parts than expected
-                const problematicRows = await (0, queryDB_js_1.default)(simpleTable, `SELECT "${column}" 
-         FROM "${simpleTable.name}" 
-         WHERE ARRAY_LENGTH(STRING_SPLIT("${column}", '${separator}')) > ${nbParts}
+                const problematicRows = await (0, queryDB_js_1.default)(simpleTable, `SELECT ${(0, quoteIdentifier_js_1.default)(column)}
+         FROM ${(0, quoteIdentifier_js_1.default)(simpleTable.name)}
+         WHERE ARRAY_LENGTH(STRING_SPLIT(${(0, quoteIdentifier_js_1.default)(column)}, ?)) > ${partCount}
          LIMIT 5`, (0, mergeOptions_js_1.default)(simpleTable, {
                     table: simpleTable.name,
                     method: "splitSpread()",
                     parameters: { column, separator, newColumns },
-                    returnDataFrom: "query",
+                    returnData: true,
+                    values: [separator],
                 }));
                 const exampleRows = problematicRows
                     ? problematicRows.map((row) => row[column]).join("\n  - ")
                     : "";
-                throw new Error(`Some rows contain more values after splitting (${maxParts}) than the number of new columns specified (${nbParts}).
-When splitting by '${separator}', each row must produce at most ${nbParts} value(s) to fit in the columns: ${newColumns.join(", ")}.
+                throw new Error(`Some rows contain more values after splitting (${maxParts}) than the number of new columns specified (${partCount}).
+When splitting by '${separator}', each row must produce at most ${partCount} value(s) to fit in the columns: ${newColumns.join(", ")}.
 
 First 5 rows with too many values:\n  - ${exampleRows}`);
             }
-        }
-        // Check if any row has fewer parts than expected
-        const minPartsResult = await (0, queryDB_js_1.default)(simpleTable, `SELECT MIN(ARRAY_LENGTH(STRING_SPLIT("${column}", '${separator}'))) as min_parts FROM "${simpleTable.name}"`, (0, mergeOptions_js_1.default)(simpleTable, {
-            table: simpleTable.name,
-            method: "splitSpread()",
-            parameters: { column, separator, newColumns },
-            returnDataFrom: "query",
-        }));
-        if (minPartsResult && minPartsResult.length > 0) {
-            const minParts = minPartsResult[0].min_parts;
-            if (minParts < nbParts) {
-                console.warn(`splitSpread() warning: Some rows contain fewer values after splitting (${minParts}) than the number of new columns (${nbParts}). Empty strings will be used for missing values.`);
+            if (minParts < partCount) {
+                console.warn(`splitSpread() warning: Some rows contain fewer values after splitting (${minParts}) than the number of new columns (${partCount}). Empty strings will be used for missing values.`);
             }
         }
     }
-    const alterStatements = newColumns
-        .map((col) => `ALTER TABLE "${simpleTable.name}" ADD "${col}" VARCHAR;`)
-        .join("\n");
-    const updateStatements = newColumns
-        .map((col, i) => `UPDATE "${simpleTable.name}" SET "${col}" = SPLIT_PART("${column}", '${separator}', ${i + 1});`)
-        .join("\n");
-    await (0, queryDB_js_1.default)(simpleTable, `${alterStatements}
-    ${updateStatements}`, (0, mergeOptions_js_1.default)(simpleTable, {
+    const split = splitSpreadQuery(simpleTable.name, column, separator, newColumns);
+    await (0, queryDB_js_1.default)(simpleTable, split.query, (0, mergeOptions_js_1.default)(simpleTable, {
         table: simpleTable.name,
         method: "splitSpread()",
         parameters: { column, separator, newColumns },
+        values: split.values,
     }));
 }
+function splitSpreadQuery(table, column, separator, newColumns) {
+    // All columns are added in a single rewrite, so the table is scanned once
+    // instead of once per ALTER + once per UPDATE.
+    const splitColumns = newColumns
+        .map((col, i) => `SPLIT_PART(${(0, quoteIdentifier_js_1.default)(column)}, ?, ${i + 1}) AS ${(0, quoteIdentifier_js_1.default)(col)}`)
+        .join(", ");
+    const query = `CREATE OR REPLACE TABLE ${(0, quoteIdentifier_js_1.default)(table)} AS SELECT *, ${splitColumns} FROM ${(0, quoteIdentifier_js_1.default)(table)}`;
+    return { query, values: newColumns.map(() => separator) };
+}

package/script/methods/stream.d.ts

@@ -0,0 +1,8 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function stream(simpleTable: SimpleTable, options?: {
+    columns?: string | string[];
+    conditions?: string;
+}): AsyncGenerator<{
+    [key: string]: unknown;
+}, void, undefined>;
+//# sourceMappingURL=stream.d.ts.map

package/script/methods/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/methods/stream.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,wBAA+B,MAAM,CACnC,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE;IACP,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;CAChB,GACL,cAAc,CAAC;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,IAAI,EAAE,SAAS,CAAC,CAmE7D"}

package/script/methods/stream.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = stream;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const runQuery_js_1 = require("../helpers/runQuery.js");
+const SDAError_js_1 = __importDefault(require("../class/SDAError.js"));
+const flushAllTables_js_1 = __importDefault(require("../helpers/flushAllTables.js"));
+const observeQuery_js_1 = __importDefault(require("../helpers/observeQuery.js"));
+async function* stream(simpleTable, options = {}) {
+    if (simpleTable.connection === undefined) {
+        await simpleTable.sdb.start();
+        simpleTable.db = simpleTable.sdb.db;
+        simpleTable.connection = simpleTable.sdb.connection;
+    }
+    // stream() reads directly from the connection instead of going through
+    // queryDB, so it must flush the pending chains itself before yielding.
+    await (0, flushAllTables_js_1.default)(simpleTable.sdb);
+    const columns = options.columns
+        ? (typeof options.columns === "string"
+            ? [options.columns]
+            : options.columns)
+        : undefined;
+    const query = `SELECT ${columns ? columns.map((d) => `${(0, quoteIdentifier_js_1.default)(d)}`).join(", ") : "*"} FROM ${(0, quoteIdentifier_js_1.default)(simpleTable.name)}${options.conditions ? ` WHERE ${options.conditions}` : ""};`;
+    try {
+        await (0, observeQuery_js_1.default)(simpleTable.connection, query, [], {
+            logSQL: simpleTable.sdb.logSQL,
+            explainSQL: simpleTable.sdb.explainSQL,
+        });
+        const result = await simpleTable.connection.stream(query);
+        const columnNames = result.deduplicatedColumnNames();
+        const columnTypes = result.columnTypes();
+        if (columnTypes.some((type) => type.toString().toLowerCase().includes("geometry"))) {
+            throw new Error("The query returns geometry columns. Use getGeoData() instead.");
+        }
+        const converters = columnTypes.map((type, i) => (0, runQuery_js_1.makeConverter)(type, columnNames[i], simpleTable.name));
+        const columnCount = columnNames.length;
+        while (true) {
+            const chunk = await result.fetchChunk();
+            if (!chunk || chunk.rowCount === 0) {
+                break;
+            }
+            for (const rawRow of chunk.getRows()) {
+                const row = {};
+                for (let i = 0; i < columnCount; i++) {
+                    row[columnNames[i]] = converters[i](rawRow[i]);
+                }
+                yield row;
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof SDAError_js_1.default) {
+            throw error;
+        }
+        throw new SDAError_js_1.default({
+            method: "stream()",
+            parameters: { options },
+            query,
+            cause: error,
+        });
+    }
+}

package/script/methods/summarize.d.ts

@@ -1,13 +1,15 @@
+import { type Stat } from "../helpers/getStatExpression.js";
 import type SimpleTable from "../class/SimpleTable.js";
-export default function summarize(SimpleTable: SimpleTable, options?: {
+type SummarizeOptions = {
     outputTable?: string | boolean;
-    values?: string | string[];
-    categories?: string | string[];
-    summaries?: ("count" | "countUnique" | "countNull" | "min" | "max" | "mean" | "median" | "sum" | "skew" | "stdDev" | "var") | ("count" | "countUnique" | "countNull" | "min" | "max" | "mean" | "median" | "sum" | "skew" | "stdDev" | "var")[] | {
-        [key: string]: "count" | "countUnique" | "countNull" | "min" | "max" | "mean" | "median" | "sum" | "skew" | "stdDev" | "var";
+    columns?: string | string[];
+    by?: string | string[];
+    stats?: Stat | Stat[] | {
+        [key: string]: Stat;
     };
     decimals?: number;
-    toMs?: boolean;
-    noColumnValue?: boolean;
-}): Promise<void>;
+    datesToMs?: boolean;
+};
+export default function summarize(simpleTable: SimpleTable, options?: SummarizeOptions): SimpleTable;
+export {};
 //# sourceMappingURL=summarize.d.ts.map

package/script/methods/summarize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"summarize.d.ts","sourceRoot":"","sources":["../../src/methods/summarize.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,SAAS,CACrC,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE;IACP,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC/B,SAAS,CAAC,EACN,CACE,OAAO,GACP,aAAa,GACb,WAAW,GACX,KAAK,GACL,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,CACR,GACC,CACE,OAAO,GACP,aAAa,GACb,WAAW,GACX,KAAK,GACL,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,CACR,EAAE,GACD;QACA,CAAC,GAAG,EAAE,MAAM,GACR,OAAO,GACP,aAAa,GACb,WAAW,GACX,KAAK,GACL,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,CAAC;KACX,CAAC;IACJ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;CACpB,iBAiFP"}
+{"version":3,"file":"summarize.d.ts","sourceRoot":"","sources":["../../src/methods/summarize.ts"],"names":[],"mappings":"AACA,OAA0B,EAGxB,KAAK,IAAI,EACV,MAAM,iCAAiC,CAAC;AAOzC,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,KAAK,gBAAgB,GAAG;IACtB,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,KAAK,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,GAAG;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IAChD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE,gBAAqB,GAC7B,WAAW,CA6Cb"}

package/script/methods/summarize.js

@@ -1,66 +1,186 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = summarize;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const getStatExpression_js_1 = __importStar(require("../helpers/getStatExpression.js"));
 const mergeOptions_js_1 = __importDefault(require("../helpers/mergeOptions.js"));
 const queryDB_js_1 = __importDefault(require("../helpers/queryDB.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+const resolveOutputTable_js_1 = __importDefault(require("../helpers/resolveOutputTable.js"));
 const stringToArray_js_1 = __importDefault(require("../helpers/stringToArray.js"));
-const summarizeQuery_js_1 = __importDefault(require("./summarizeQuery.js"));
-async function summarize(SimpleTable, options = {}) {
-    const outputTable = typeof options.outputTable === "string"
-        ? options.outputTable
-        : SimpleTable.name;
-    options.values = options.values ? (0, stringToArray_js_1.default)(options.values) : [];
-    if (options.values.length === 0) {
-        await SimpleTable.addRowNumber("rowNumberToSummarizeQuerySDA");
-        options.values = ["rowNumberToSummarizeQuerySDA"];
+function summarize(simpleTable, options = {}) {
+    options = structuredClone(options);
+    options.outputTable = (0, resolveOutputTable_js_1.default)(simpleTable, options.outputTable);
+    const columns = getSummarizeColumns(options);
+    const boundColumns = columns.length > 1 ? columns : [];
+    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);
+        (0, queueOp_js_1.default)(outputTable, {
+            kind: "barrier",
+            method: "summarize()",
+            parameters: { options },
+            execute: async () => {
+                await (0, queryDB_js_1.default)(simpleTable, `CREATE OR REPLACE TABLE ${(0, quoteIdentifier_js_1.default)(outputTable.name)} AS ${summarizeSelect(`${(0, quoteIdentifier_js_1.default)(simpleTable.name)}`, await simpleTable.getTypes(), options)}`, (0, mergeOptions_js_1.default)(simpleTable, {
+                    table: outputTable.name,
+                    method: "summarize()",
+                    parameters: { options },
+                    values: boundColumns,
+                }));
+            },
+        });
+        return outputTable;
+    }
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "summarize()",
+        parameters: { options },
+        needsSchema: true,
+        values: boundColumns,
+        buildSelect: (input, types) => summarizeSelect(input, types, options),
+    });
+    return simpleTable;
+}
+function getSummarizeColumns(options) {
+    const by = options.by ? (0, stringToArray_js_1.default)(options.by) : [];
+    return [
+        ...new Set((options.columns ? (0, stringToArray_js_1.default)(options.columns) : []).filter((column) => !by.includes(column))),
+    ];
+}
+function summarizeSelect(input, types, options) {
+    const by = options.by ? (0, stringToArray_js_1.default)(options.by) : [];
+    // Duplicated columns would duplicate rows now that the branches are combined
+    // with UNION ALL instead of a deduplicating UNION.
+    const columns = getSummarizeColumns(options);
+    let stats;
+    let outputColumns;
+    if (options.stats === undefined) {
+        stats = columns.length === 0 ? ["count"] : [...getStatExpression_js_1.allStats];
+    }
+    else if (typeof options.stats === "string") {
+        stats = [options.stats];
     }
-    options.categories = options.categories
-        ? (0, stringToArray_js_1.default)(options.categories)
-        : [];
-    let columns;
-    if (options.summaries === undefined) {
-        if (options.values.length === 1 &&
-            options.values[0] === "rowNumberToSummarizeQuerySDA") {
-            options.summaries = ["count"];
+    else if (Array.isArray(options.stats)) {
+        stats = options.stats.length === 0 ? [...getStatExpression_js_1.allStats] : options.stats;
+    }
+    else {
+        const entries = Object.entries(options.stats);
+        outputColumns = entries.map((d) => d[0]);
+        stats = entries.map((d) => d[1]);
+    }
+    // The `column` output column is a row key that distinguishes rows for
+    // different input columns, so it appears only when there is more than one.
+    const columnColumn = columns.length > 1;
+    // With datesToMs, dates are converted to milliseconds inside the aggregate
+    // expressions (same conversions as convert()), so the input table is left
+    // untouched instead of being rewritten.
+    const references = {};
+    const effectiveTypes = {};
+    for (const column of columns) {
+        const type = types[column];
+        if (options.datesToMs === true &&
+            typeof type === "string" &&
+            (type.includes("TIME") || type.includes("DATE"))) {
+            references[column] = type.includes("TIME")
+                ? `(date_part('epoch', ${(0, quoteIdentifier_js_1.default)(column)}) * 1000)`
+                : `(epoch(${(0, quoteIdentifier_js_1.default)(column)}) * 1000)`;
+            effectiveTypes[column] = "BIGINT";
         }
         else {
-            options.summaries = [];
+            references[column] = `${(0, quoteIdentifier_js_1.default)(column)}`;
+            effectiveTypes[column] = type;
         }
     }
-    else if (typeof options.summaries === "string") {
-        options.summaries = [options.summaries];
+    const columnTypes = columns.map((d) => effectiveTypes[d]);
+    const doubleAndDate = columnTypes.includes("DOUBLE") &&
+        columnTypes.some(getStatExpression_js_1.isTemporalStatType);
+    if (doubleAndDate) {
+        throw new Error("You are trying to summarize numbers and timestamps/dates/times. You can specify columns in the options (just numbers or just timestamps/dates/times) or convert your timestamps/dates/times to the number of ms since 1970-01-01 00:00:00 by passing the option { datesToMs: true }.");
     }
-    else if (!Array.isArray(options.summaries) && typeof options.summaries === "object") {
-        const entries = Object.entries(options.summaries);
-        columns = entries.map((d) => d[0]);
-        options.summaries = entries.map((d) => d[1]);
+    const bySelect = by.map((d) => `${(0, quoteIdentifier_js_1.default)(d)}`).join(", ");
+    const groupBy = by.length > 0 ? `\nGROUP BY ${bySelect}` : "";
+    // With no columns, the only meaningful statistic is the row count, which
+    // doesn't need an input-column label (or any temporary column) at all.
+    if (columns.length === 0) {
+        const statColumns = stats.map((stat, i) => {
+            const name = outputColumns ? outputColumns[i] : stat;
+            return stat === "count"
+                ? `CAST(COUNT(*) AS INTEGER) AS ${(0, quoteIdentifier_js_1.default)(name)}`
+                : `NULL AS ${(0, quoteIdentifier_js_1.default)(name)}`;
+        });
+        const orderBy = by.length > 0
+            ? `\nORDER BY ${by.map((d) => `${(0, quoteIdentifier_js_1.default)(d)} ASC`).join(", ")}`
+            : "";
+        return `SELECT ${[
+            ...by.map((d) => `${(0, quoteIdentifier_js_1.default)(d)}`),
+            ...statColumns,
+        ].join(", ")}\nFROM ${input}${groupBy}${orderBy}`;
     }
-    const types = await SimpleTable.getTypes();
-    if (options.toMs) {
-        const toMsObj = {};
-        for (const key of Object.keys(types)) {
-            if (types[key].includes("TIME") || types[key].includes("DATE")) {
-                toMsObj[key] = "bigint";
-                types[key] = "bigint";
+    // One UNION ALL branch per input column. DuckDB runs the branches as
+    // concurrent pipelines, which parallelizes the expensive aggregates
+    // (medians, distinct counts) better than computing them all in one scan.
+    const branches = [];
+    for (const column of columns) {
+        let hasAggregate = false;
+        const projections = stats.map((stat, j) => {
+            const name = outputColumns ? outputColumns[j] : stat;
+            const expression = (0, getStatExpression_js_1.default)(stat, effectiveTypes[column], references[column], options.decimals);
+            if (expression === null) {
+                return `NULL AS ${(0, quoteIdentifier_js_1.default)(name)}`;
             }
+            hasAggregate = true;
+            return `${expression} AS ${(0, quoteIdentifier_js_1.default)(name)}`;
+        });
+        const select = `SELECT ${columnColumn ? `? AS ${(0, quoteIdentifier_js_1.default)("column")}, ` : ""}${bySelect === "" ? "" : `${bySelect}, `}${projections.join(", ")}`;
+        if (by.length === 0 && !hasAggregate) {
+            // Every statistic is NULL and there is nothing to group by: the branch
+            // is a single constant row, so the input is not even scanned.
+            branches.push(select);
         }
-        await SimpleTable.convert(toMsObj);
-    }
-    options.values = options.values.filter((d) => !options.categories?.includes(d));
-    await (0, queryDB_js_1.default)(SimpleTable, (0, summarizeQuery_js_1.default)(SimpleTable.name, types, outputTable, options.values, options.categories, options.summaries, options, columns), (0, mergeOptions_js_1.default)(SimpleTable, {
-        table: outputTable,
-        method: "summarize()",
-        parameters: {
-            options,
-        },
-    }));
-    if (options.values.includes("rowNumberToSummarizeQuerySDA")) {
-        if (await SimpleTable.hasColumn("rowNumberToSummarizeQuerySDA")) {
-            await SimpleTable.removeColumns("rowNumberToSummarizeQuerySDA");
+        else {
+            branches.push(`${select}\nFROM ${input}${groupBy}`);
         }
-        SimpleTable.sdb.customQuery(`ALTER TABLE "${outputTable}" DROP COLUMN value;`);
     }
+    const orderByColumns = columnColumn ? ["column", ...by] : by;
+    const orderBy = orderByColumns.length > 0
+        ? `\nORDER BY ${orderByColumns.map((d) => `${(0, quoteIdentifier_js_1.default)(d)} ASC`).join(", ")}`
+        : "";
+    return `${branches.join("\nUNION ALL\n")}${orderBy}`;
 }

package/script/methods/trim.d.ts

@@ -0,0 +1,6 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function trim(simpleTable: SimpleTable, columns: string | string[], options?: {
+    character?: string;
+    side?: "left" | "right" | "both";
+}): void;
+//# sourceMappingURL=trim.d.ts.map

package/script/methods/trim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trim.d.ts","sourceRoot":"","sources":["../../src/methods/trim.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAC1B,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;CAC7B,QAuCP"}

package/script/methods/trim.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = trim;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const stringToArray_js_1 = __importDefault(require("../helpers/stringToArray.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function trim(simpleTable, columns, options = {}) {
+    const cols = (0, stringToArray_js_1.default)(columns);
+    const side = options.side ?? "both";
+    const fn = side === "left"
+        ? "LTRIM"
+        : side === "right"
+            ? "RTRIM"
+            : side === "both"
+                ? "TRIM"
+                : null;
+    if (fn === null) {
+        throw new Error(`trim() options.side must be "left", "right", or "both". Received ${JSON.stringify(options.side)}.`);
+    }
+    const specialCharacter = typeof options.character === "string" ? ", ?" : "";
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "trim()",
+        parameters: { columns, options },
+        values: typeof options.character === "string"
+            ? cols.map(() => options.character)
+            : undefined,
+        needsSchema: false,
+        buildSelect: (input) => `SELECT * REPLACE (${cols
+            .map((c) => `${fn}(${(0, quoteIdentifier_js_1.default)(c)}${specialCharacter}) AS ${(0, quoteIdentifier_js_1.default)(c)}`)
+            .join(", ")}) FROM ${input}`,
+    });
+}

package/script/methods/truncate.d.ts

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

package/script/methods/truncate.d.ts.map

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

package/script/methods/truncate.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = truncate;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function truncate(simpleTable, column, length) {
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "truncate()",
+        parameters: { column, length },
+        needsSchema: false,
+        buildSelect: (input) => `SELECT * REPLACE (LEFT(${(0, quoteIdentifier_js_1.default)(column)}, ${length}) AS ${(0, quoteIdentifier_js_1.default)(column)}) FROM ${input}`,
+    });
+}

package/script/methods/union.d.ts

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

package/script/methods/union.d.ts.map

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

package/script/methods/union.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = union;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function union(simpleTable, column1, column2, newColumn) {
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "union()",
+        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_Union(${(0, quoteIdentifier_js_1.default)(column1)}, ${(0, quoteIdentifier_js_1.default)(column2)})::${types[column1]}`;
+            return Object.keys(types).includes(newColumn)
+                ? `SELECT * REPLACE (${expression} AS ${(0, quoteIdentifier_js_1.default)(newColumn)}) FROM ${input}`
+                : `SELECT *, ${expression} AS ${(0, quoteIdentifier_js_1.default)(newColumn)} FROM ${input}`;
+        },
+    });
+}

package/script/methods/unnest.d.ts

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

package/script/methods/unnest.d.ts.map

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