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

package/esm/methods/selectRows.js

@@ -0,0 +1,34 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import queueOp from "../helpers/queueOp.js";
+import resolveOutputTable from "../helpers/resolveOutputTable.js";
+export default function selectRows(simpleTable, count, options = {}) {
+    options = { ...options };
+    options.outputTable = resolveOutputTable(simpleTable, options.outputTable);
+    const limitAndOffset = `LIMIT ${count}${typeof options.offset === "number" ? ` OFFSET ${options.offset}` : ""}`;
+    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: "source",
+            method: "selectRows()",
+            parameters: { count, options },
+            // The output table reads simpleTable by name rather than through its
+            // own (nonexistent) chain, so simpleTable's pending work must close
+            // and execute before this SELECT runs, as it would at this call
+            // position.
+            rawSQL: [`${quoteIdentifier(simpleTable.name)}`],
+            buildSelect: () => `SELECT * FROM ${quoteIdentifier(simpleTable.name)} ${limitAndOffset}`,
+        });
+        return outputTable;
+    }
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "selectRows()",
+        parameters: { count, options },
+        needsSchema: false,
+        preservesSchema: true,
+        buildSelect: (input) => `SELECT * FROM ${input} ${limitAndOffset}`,
+    });
+    return simpleTable;
+}

package/esm/methods/selectTables.d.ts

@@ -0,0 +1,4 @@
+import SimpleTable from "../class/SimpleTable.js";
+import type SimpleDB from "../class/SimpleDB.js";
+export default function selectTables(simpleDB: SimpleDB, tables: SimpleTable | string | (SimpleTable | string)[]): Promise<void>;
+//# sourceMappingURL=selectTables.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectTables.d.ts","sourceRoot":"","sources":["../../src/methods/selectTables.ts"],"names":[],"mappings":"AAGA,OAAO,WAAW,MAAM,yBAAyB,CAAC;AAClD,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AAKjD,wBAA8B,YAAY,CACxC,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,WAAW,GAAG,MAAM,GAAG,CAAC,WAAW,GAAG,MAAM,CAAC,EAAE,iBA+CxD"}

package/esm/methods/selectTables.js

@@ -0,0 +1,25 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import SimpleTable from "../class/SimpleTable.js";
+import { retainRegisteredTables } from "../helpers/tableRegistry.js";
+import assertSameDatabase from "../helpers/assertSameDatabase.js";
+import formatMissingTables from "../helpers/formatMissingTables.js";
+export default async function selectTables(simpleDB, tables) {
+    const selected = Array.isArray(tables) ? tables : [tables];
+    assertSameDatabase(simpleDB, selected.filter((table) => table instanceof SimpleTable), "selectTables()");
+    const tablesToBeSelected = selected.map((t) => t instanceof SimpleTable ? t.name : t);
+    const existingTables = await simpleDB.getTableNames();
+    const missingTables = tablesToBeSelected.filter((table) => !existingTables.includes(table));
+    if (missingTables.length > 0) {
+        throw new Error(formatMissingTables("selectTables()", missingTables, existingTables));
+    }
+    const tablesToBeRemoved = simpleDB.getTables().filter((t) => !tablesToBeSelected.includes(t.name));
+    await queryDB(simpleDB, tablesToBeRemoved.map((d) => `DROP TABLE ${quoteIdentifier(d instanceof SimpleTable ? d.name : d)};`).join("\n"), mergeOptions(simpleDB, {
+        table: null,
+        method: "removeTable()",
+        parameters: {},
+    }));
+    const tablesNamesToBeRemoved = tablesToBeRemoved.map((t) => t instanceof SimpleTable ? t.name : t);
+    retainRegisteredTables(simpleDB, (table) => !tablesNamesToBeRemoved.includes(table.name));
+}

package/esm/methods/setTypes.d.ts

@@ -0,0 +1,5 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function setTypes(simpleTable: SimpleTable, types: {
+    [key: string]: "integer" | "float" | "number" | "string" | "date" | "time" | "datetime" | "datetimeTz" | "bigint" | "double" | "varchar" | "timestamp" | "timestamp with time zone" | "boolean" | `geometry('${string}')` | `GEOMETRY('${string}')`;
+}): void;
+//# sourceMappingURL=setTypes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setTypes.d.ts","sourceRoot":"","sources":["../../src/methods/setTypes.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,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,GACT,aAAa,MAAM,IAAI,GACvB,aAAa,MAAM,IAAI,CAAC;CAC7B,QAkCF"}

package/esm/methods/setTypes.js

@@ -0,0 +1,30 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import ensureSpatial from "../helpers/ensureSpatial.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import parseType from "../helpers/parseTypes.js";
+import queryDB from "../helpers/queryDB.js";
+import queueOp from "../helpers/queueOp.js";
+export default function setTypes(simpleTable, types) {
+    // Creating a table from scratch (possibly with the spatial extension) is
+    // multi-statement by nature: it executes as a barrier.
+    types = structuredClone(types);
+    queueOp(simpleTable, {
+        kind: "barrier",
+        method: "setTypes()",
+        parameters: { types },
+        execute: async () => {
+            if (Object.values(types)
+                .map((d) => d.toLowerCase())
+                .some((d) => d.startsWith("geometry"))) {
+                await ensureSpatial(simpleTable);
+            }
+            await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(simpleTable.name)} (${Object.keys(types)
+                .map((d) => `${quoteIdentifier(d)} ${parseType(types[d])}`)
+                .join(", ")});`, mergeOptions(simpleTable, {
+                table: simpleTable.name,
+                method: "setTypes()",
+                parameters: { types },
+            }));
+        },
+    });
+}

package/esm/methods/simplify.d.ts

@@ -0,0 +1,6 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function simplify(simpleTable: SimpleTable, tolerance: number, options?: {
+    column?: string;
+    simplifyBoundary?: boolean;
+}): void;
+//# sourceMappingURL=simplify.d.ts.map

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

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

package/esm/methods/simplify.js

@@ -0,0 +1,38 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import ensureSpatial from "../helpers/ensureSpatial.js";
+import findGeoColumn from "../helpers/findGeoColumn.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import queueOp from "../helpers/queueOp.js";
+export default function simplify(simpleTable, tolerance, options = {}) {
+    // The coverage simplification groups by rowid, which only exists on the
+    // materialized table: it executes as a barrier.
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "barrier",
+        method: "simplify()",
+        parameters: { tolerance, options },
+        execute: () => executeSimplify(simpleTable, tolerance, options),
+    });
+}
+async function executeSimplify(simpleTable, tolerance, options) {
+    await ensureSpatial(simpleTable);
+    const column = typeof options.column === "string"
+        ? options.column
+        : await findGeoColumn(simpleTable, "simplify()");
+    const geoType = await simpleTable.getProjection(column);
+    // Each row is its own coverage group: grouping by rowid directly avoids
+    // materializing a temporary row-number column. rowid is not part of
+    // SELECT *, so the other columns are listed explicitly in the GROUP BY.
+    const groupBy = [
+        "rowid",
+        ...(await simpleTable.getColumns())
+            .filter((d) => d !== column)
+            .map((d) => `${quoteIdentifier(d)}`),
+    ].join(", ");
+    await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(simpleTable.name)} AS SELECT * REPLACE(ST_CoverageSimplify(ARRAY_AGG(${quoteIdentifier(column)}), ${tolerance}${options.simplifyBoundary === false ? ", FAlSE" : ""})::${geoType} AS ${quoteIdentifier(column)}) FROM ${quoteIdentifier(simpleTable.name)} GROUP BY ${groupBy};`, mergeOptions(simpleTable, {
+        table: simpleTable.name,
+        method: "simplify()",
+        parameters: { column, tolerance },
+    }));
+}

package/esm/methods/skip.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"skip.d.ts","sourceRoot":"","sources":["../../src/methods/skip.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,MAAM,QAUd"}

package/esm/methods/skip.js

@@ -0,0 +1,11 @@
+import queueOp from "../helpers/queueOp.js";
+export default function skip(simpleTable, count) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "skip()",
+        parameters: { count },
+        needsSchema: false,
+        preservesSchema: true,
+        buildSelect: (input) => `SELECT * FROM ${input} OFFSET ${count} ROWS`,
+    });
+}

package/esm/methods/sort.d.ts

@@ -0,0 +1,9 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function sort(simpleTable: SimpleTable, order?: {
+    [key: string]: "asc" | "desc";
+} | null, options?: {
+    lang?: {
+        [key: string]: string;
+    };
+}): void;
+//# sourceMappingURL=sort.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../src/methods/sort.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,WAAW,EAAE,WAAW,EACxB,KAAK,GAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,CAAA;CAAE,GAAG,IAAW,EACtD,OAAO,GAAE;IACP,IAAI,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CAC7B,QAeP"}

package/esm/methods/sort.js

@@ -0,0 +1,35 @@
+import queueOp from "../helpers/queueOp.js";
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+export default function sort(simpleTable, order = null, options = {}) {
+    const capturedOrder = order === null ? null : { ...order };
+    const capturedOptions = {
+        ...options,
+        lang: options.lang === undefined ? undefined : { ...options.lang },
+    };
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "sort()",
+        parameters: { order: capturedOrder, options: capturedOptions },
+        needsSchema: false,
+        preservesSchema: true,
+        buildSelect: (input) => sortSelect(input, capturedOrder, capturedOptions),
+    });
+}
+function sortSelect(input, order, options = {}) {
+    let query = `SELECT * FROM ${input}
+    ORDER BY`;
+    if (order === null) {
+        query += " ALL,";
+    }
+    else {
+        for (const column of Object.keys(order)) {
+            if (options.lang && options.lang[column]) {
+                query += `\n${quoteIdentifier(column)} COLLATE ${options.lang[column]} ${order[column].toUpperCase()},`;
+            }
+            else {
+                query += `\n${quoteIdentifier(column)} ${order[column].toUpperCase()},`;
+            }
+        }
+    }
+    return query.slice(0, query.length - 1);
+}

package/esm/methods/splitExtract.d.ts

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

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

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

package/esm/methods/splitExtract.js

@@ -0,0 +1,21 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import assertNewColumns from "../helpers/assertNewColumns.js";
+import queueOp from "../helpers/queueOp.js";
+export default function splitExtract(simpleTable, column, separator, index, newColumn) {
+    queueOp(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.
+            assertNewColumns(types, [newColumn], "splitExtract()", [column]);
+            const expression = `SPLIT_PART(${quoteIdentifier(column)}, ?, ${index + 1})`;
+            return column === newColumn
+                ? `SELECT * REPLACE (${expression} AS ${quoteIdentifier(newColumn)}) FROM ${input}`
+                : `SELECT *, ${expression} AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}

package/esm/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/esm/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/esm/methods/splitSpread.js

@@ -1,61 +1,84 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import assertNewColumns from "../helpers/assertNewColumns.js";
 import mergeOptions from "../helpers/mergeOptions.js";
 import queryDB from "../helpers/queryDB.js";
-export default 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 queryDB(simpleTable, `SELECT MAX(ARRAY_LENGTH(STRING_SPLIT("${column}", '${separator}'))) as max_parts FROM "${simpleTable.name}"`, mergeOptions(simpleTable, {
+import queueOp from "../helpers/queueOp.js";
+export default 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.
+    queueOp(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.
+    assertNewColumns(await simpleTable.getTypes(), newColumns, "splitSpread()");
+    if (strict) {
+        // Both bounds come from the same scan instead of one query each.
+        const partsResult = await queryDB(simpleTable, `SELECT
+        MAX(ARRAY_LENGTH(STRING_SPLIT(${quoteIdentifier(column)}, ?))) AS max_parts,
+        MIN(ARRAY_LENGTH(STRING_SPLIT(${quoteIdentifier(column)}, ?))) AS min_parts
+      FROM ${quoteIdentifier(simpleTable.name)}`, mergeOptions(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 queryDB(simpleTable, `SELECT "${column}" 
-         FROM "${simpleTable.name}" 
-         WHERE ARRAY_LENGTH(STRING_SPLIT("${column}", '${separator}')) > ${nbParts}
+                const problematicRows = await queryDB(simpleTable, `SELECT ${quoteIdentifier(column)}
+         FROM ${quoteIdentifier(simpleTable.name)}
+         WHERE ARRAY_LENGTH(STRING_SPLIT(${quoteIdentifier(column)}, ?)) > ${partCount}
          LIMIT 5`, mergeOptions(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 queryDB(simpleTable, `SELECT MIN(ARRAY_LENGTH(STRING_SPLIT("${column}", '${separator}'))) as min_parts FROM "${simpleTable.name}"`, mergeOptions(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 queryDB(simpleTable, `${alterStatements}
-    ${updateStatements}`, mergeOptions(simpleTable, {
+    const split = splitSpreadQuery(simpleTable.name, column, separator, newColumns);
+    await queryDB(simpleTable, split.query, mergeOptions(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(${quoteIdentifier(column)}, ?, ${i + 1}) AS ${quoteIdentifier(col)}`)
+        .join(", ");
+    const query = `CREATE OR REPLACE TABLE ${quoteIdentifier(table)} AS SELECT *, ${splitColumns} FROM ${quoteIdentifier(table)}`;
+    return { query, values: newColumns.map(() => separator) };
+}

package/esm/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/esm/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/esm/methods/stream.js

@@ -0,0 +1,59 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import { makeConverter } from "../helpers/runQuery.js";
+import SDAError from "../class/SDAError.js";
+import flushAllTables from "../helpers/flushAllTables.js";
+import observeQuery from "../helpers/observeQuery.js";
+export default 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 flushAllTables(simpleTable.sdb);
+    const columns = options.columns
+        ? (typeof options.columns === "string"
+            ? [options.columns]
+            : options.columns)
+        : undefined;
+    const query = `SELECT ${columns ? columns.map((d) => `${quoteIdentifier(d)}`).join(", ") : "*"} FROM ${quoteIdentifier(simpleTable.name)}${options.conditions ? ` WHERE ${options.conditions}` : ""};`;
+    try {
+        await observeQuery(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) => 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) {
+            throw error;
+        }
+        throw new SDAError({
+            method: "stream()",
+            parameters: { options },
+            query,
+            cause: error,
+        });
+    }
+}

package/esm/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/esm/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"}