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

package/esm/methods/summarize.js

@@ -1,60 +1,147 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import getStatExpression, { allStats, isTemporalStatType, } from "../helpers/getStatExpression.js";
 import mergeOptions from "../helpers/mergeOptions.js";
 import queryDB from "../helpers/queryDB.js";
+import queueOp from "../helpers/queueOp.js";
+import resolveOutputTable from "../helpers/resolveOutputTable.js";
 import stringToArray from "../helpers/stringToArray.js";
-import summarizeQuery from "./summarizeQuery.js";
-export default async function summarize(SimpleTable, options = {}) {
-    const outputTable = typeof options.outputTable === "string"
-        ? options.outputTable
-        : SimpleTable.name;
-    options.values = options.values ? stringToArray(options.values) : [];
-    if (options.values.length === 0) {
-        await SimpleTable.addRowNumber("rowNumberToSummarizeQuerySDA");
-        options.values = ["rowNumberToSummarizeQuerySDA"];
-    }
-    options.categories = options.categories
-        ? stringToArray(options.categories)
-        : [];
-    let columns;
-    if (options.summaries === undefined) {
-        if (options.values.length === 1 &&
-            options.values[0] === "rowNumberToSummarizeQuerySDA") {
-            options.summaries = ["count"];
+export default function summarize(simpleTable, options = {}) {
+    options = structuredClone(options);
+    options.outputTable = resolveOutputTable(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);
+        queueOp(outputTable, {
+            kind: "barrier",
+            method: "summarize()",
+            parameters: { options },
+            execute: async () => {
+                await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable.name)} AS ${summarizeSelect(`${quoteIdentifier(simpleTable.name)}`, await simpleTable.getTypes(), options)}`, mergeOptions(simpleTable, {
+                    table: outputTable.name,
+                    method: "summarize()",
+                    parameters: { options },
+                    values: boundColumns,
+                }));
+            },
+        });
+        return outputTable;
+    }
+    queueOp(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 ? stringToArray(options.by) : [];
+    return [
+        ...new Set((options.columns ? stringToArray(options.columns) : []).filter((column) => !by.includes(column))),
+    ];
+}
+function summarizeSelect(input, types, options) {
+    const by = options.by ? stringToArray(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"] : [...allStats];
+    }
+    else if (typeof options.stats === "string") {
+        stats = [options.stats];
+    }
+    else if (Array.isArray(options.stats)) {
+        stats = options.stats.length === 0 ? [...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', ${quoteIdentifier(column)}) * 1000)`
+                : `(epoch(${quoteIdentifier(column)}) * 1000)`;
+            effectiveTypes[column] = "BIGINT";
         }
         else {
-            options.summaries = [];
+            references[column] = `${quoteIdentifier(column)}`;
+            effectiveTypes[column] = type;
         }
     }
-    else if (typeof options.summaries === "string") {
-        options.summaries = [options.summaries];
-    }
-    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 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";
+    const columnTypes = columns.map((d) => effectiveTypes[d]);
+    const doubleAndDate = columnTypes.includes("DOUBLE") &&
+        columnTypes.some(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 }.");
+    }
+    const bySelect = by.map((d) => `${quoteIdentifier(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 ${quoteIdentifier(name)}`
+                : `NULL AS ${quoteIdentifier(name)}`;
+        });
+        const orderBy = by.length > 0
+            ? `\nORDER BY ${by.map((d) => `${quoteIdentifier(d)} ASC`).join(", ")}`
+            : "";
+        return `SELECT ${[
+            ...by.map((d) => `${quoteIdentifier(d)}`),
+            ...statColumns,
+        ].join(", ")}\nFROM ${input}${groupBy}${orderBy}`;
+    }
+    // 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 = getStatExpression(stat, effectiveTypes[column], references[column], options.decimals);
+            if (expression === null) {
+                return `NULL AS ${quoteIdentifier(name)}`;
             }
+            hasAggregate = true;
+            return `${expression} AS ${quoteIdentifier(name)}`;
+        });
+        const select = `SELECT ${columnColumn ? `? AS ${quoteIdentifier("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 queryDB(SimpleTable, summarizeQuery(SimpleTable.name, types, outputTable, options.values, options.categories, options.summaries, options, columns), mergeOptions(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) => `${quoteIdentifier(d)} ASC`).join(", ")}`
+        : "";
+    return `${branches.join("\nUNION ALL\n")}${orderBy}`;
 }

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

@@ -0,0 +1,30 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import stringToArray from "../helpers/stringToArray.js";
+import queueOp from "../helpers/queueOp.js";
+export default function trim(simpleTable, columns, options = {}) {
+    const cols = stringToArray(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" ? ", ?" : "";
+    queueOp(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}(${quoteIdentifier(c)}${specialCharacter}) AS ${quoteIdentifier(c)}`)
+            .join(", ")}) FROM ${input}`,
+    });
+}

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

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

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

@@ -0,0 +1,19 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import queueOp from "../helpers/queueOp.js";
+export default function union(simpleTable, column1, column2, newColumn) {
+    queueOp(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(${quoteIdentifier(column1)}, ${quoteIdentifier(column2)})::${types[column1]}`;
+            return Object.keys(types).includes(newColumn)
+                ? `SELECT * REPLACE (${expression} AS ${quoteIdentifier(newColumn)}) FROM ${input}`
+                : `SELECT *, ${expression} AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}

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

package/esm/methods/unnest.js

@@ -0,0 +1,15 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import queueOp from "../helpers/queueOp.js";
+export default function unnest(simpleTable, column, separator) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "unnest()",
+        parameters: { column, separator },
+        values: [separator],
+        needsSchema: false,
+        buildSelect: (input) => `SELECT
+  * EXCLUDE ${quoteIdentifier(column)},
+  TRIM(UNNEST(SPLIT(${quoteIdentifier(column)}, ?))) AS ${quoteIdentifier(column)}
+FROM ${input}`,
+    });
+}

package/esm/methods/unnestGeo.d.ts

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

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

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

package/esm/methods/unnestGeo.js

@@ -0,0 +1,18 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
+import queueOp from "../helpers/queueOp.js";
+export default function unnestGeo(simpleTable, column) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "unnestGeo()",
+        parameters: { column },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            const col = column ??
+                findGeoColumnFromSchema(types, "unnestGeo()", simpleTable.name);
+            // The recursive UNNEST adds a path column, removed by the outer SELECT.
+            return `SELECT * EXCLUDE(path) FROM (SELECT * EXCLUDE(${quoteIdentifier(col)}), UNNEST(ST_Dump(${quoteIdentifier(col)}), recursive := TRUE) FROM ${input})`;
+        },
+    });
+}

package/esm/methods/updateColumn.d.ts

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

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

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

package/esm/methods/updateColumn.js

@@ -0,0 +1,15 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import queueOp from "../helpers/queueOp.js";
+export default function updateColumn(simpleTable, column, definition) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "updateColumn()",
+        parameters: { column, definition },
+        // The schema is needed to keep the column's type: UPDATE casts the
+        // definition to the column's type on assignment.
+        needsSchema: true,
+        rawSQL: [definition],
+        preservesSchema: true,
+        buildSelect: (input, types) => `SELECT * REPLACE (CAST((${definition}) AS ${types[column]}) AS ${quoteIdentifier(column)}) FROM ${input}`,
+    });
+}

package/esm/methods/updateWithJS.d.ts

@@ -0,0 +1,11 @@
+import type SimpleTable from "../class/SimpleTable.js";
+type Row = {
+    [key: string]: unknown;
+};
+type DataModifier = (rows: Row[]) => Row[] | Promise<Row[]>;
+type UpdateWithJSOptions = {
+    batchSize?: number;
+};
+export default function updateWithJS(simpleTable: SimpleTable, dataModifier: DataModifier, options?: UpdateWithJSOptions): void;
+export {};
+//# sourceMappingURL=updateWithJS.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"updateWithJS.d.ts","sourceRoot":"","sources":["../../src/methods/updateWithJS.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAKvD,KAAK,GAAG,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC;AAEtC,KAAK,YAAY,GAAG,CAClB,IAAI,EAAE,GAAG,EAAE,KACR,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;AAE5B,KAAK,mBAAmB,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAElD,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,YAAY,EAC1B,OAAO,GAAE,mBAAwB,GAChC,IAAI,CAeN"}

package/esm/methods/updateWithJS.js

@@ -0,0 +1,95 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import { retainRegisteredTables } from "../helpers/tableRegistry.js";
+import queueOp from "../helpers/queueOp.js";
+import { executePreparedArray, prepareArray } from "./loadArray.js";
+export default function updateWithJS(simpleTable, dataModifier, options = {}) {
+    if (options.batchSize !== undefined &&
+        (!Number.isInteger(options.batchSize) || options.batchSize < 1)) {
+        throw new Error("updateWithJS() batchSize must be a positive integer.");
+    }
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "barrier",
+        method: "updateWithJS()",
+        parameters: { options },
+        execute: () => executeUpdateWithJS(simpleTable, dataModifier, options),
+    });
+}
+async function executeUpdateWithJS(simpleTable, dataModifier, options) {
+    const types = await simpleTable.getTypes();
+    // Geometry columns are typed as GEOMETRY('<crs>'), not a bare "GEOMETRY".
+    if (Object.values(types).some((d) => d.toUpperCase().startsWith("GEOMETRY"))) {
+        throw new Error("updateWithJS doesn't work with tables containing geometries.");
+    }
+    if (options.batchSize === undefined) {
+        const oldData = await simpleTable.getData();
+        if (!oldData) {
+            throw new Error("No data from getData.");
+        }
+        const newData = await dataModifier(oldData);
+        if (newData.length === 0) {
+            if (oldData.length === 0) {
+                // Empty table in, empty data out: nothing to update.
+                return;
+            }
+            throw new Error("The dataModifier returned no rows. updateWithJS can't infer the table schema from zero rows.");
+        }
+        await executePreparedArray(simpleTable, prepareArray(newData));
+        return;
+    }
+    const batchSize = options.batchSize;
+    if (Object.keys(types).includes("__sda_rowid")) {
+        throw new Error('The table has a column named "__sda_rowid", which conflicts with the internal column used by the batchSize option. Rename it or run updateWithJS without batchSize.');
+    }
+    const rowCount = await simpleTable.getRowCount();
+    if (rowCount === 0) {
+        // Same behavior as the non-batched path on an empty table.
+        const newData = await dataModifier([]);
+        if (newData.length === 0) {
+            return;
+        }
+        await executePreparedArray(simpleTable, prepareArray(newData));
+        return;
+    }
+    // Rows are pulled in batches by rowid, passed through the modifier, and
+    // accumulated in a temporary table, so only one batch of rows is
+    // materialized in JS memory at a time.
+    const suffix = Math.random().toString(36).slice(2, 10);
+    const scratch = simpleTable.sdb.newTable(`updateWithJS_scratch_${suffix}`);
+    const accumulator = `updateWithJS_accumulator_${suffix}`;
+    try {
+        let first = true;
+        let lastRowid = null;
+        while (true) {
+            const batch = (await simpleTable.sdb.customQuery(`SELECT *, rowid AS __sda_rowid FROM ${quoteIdentifier(simpleTable.name)}${lastRowid === null ? "" : ` WHERE rowid > ${lastRowid}`} ORDER BY rowid LIMIT ${batchSize}`, { returnData: true }));
+            if (batch.length === 0) {
+                break;
+            }
+            lastRowid = batch[batch.length - 1].__sda_rowid;
+            for (const row of batch) {
+                delete row.__sda_rowid;
+            }
+            const modified = await dataModifier(batch);
+            if (modified.length === 0) {
+                continue;
+            }
+            await executePreparedArray(scratch, prepareArray(modified));
+            if (first) {
+                await simpleTable.sdb.customQuery(`CREATE OR REPLACE TABLE ${quoteIdentifier(accumulator)} AS SELECT * FROM ${quoteIdentifier(scratch.name)}`);
+                first = false;
+            }
+            else {
+                await simpleTable.sdb.customQuery(`INSERT INTO ${quoteIdentifier(accumulator)} BY NAME SELECT * FROM ${quoteIdentifier(scratch.name)}`);
+            }
+        }
+        if (first) {
+            throw new Error("The dataModifier returned no rows. updateWithJS can't infer the table schema from zero rows.");
+        }
+        await simpleTable.sdb.customQuery(`CREATE OR REPLACE TABLE ${quoteIdentifier(simpleTable.name)} AS SELECT * FROM ${quoteIdentifier(accumulator)}`);
+    }
+    finally {
+        await simpleTable.sdb.customQuery(`DROP TABLE IF EXISTS ${quoteIdentifier(accumulator)};
+DROP TABLE IF EXISTS ${quoteIdentifier(scratch.name)};`);
+        retainRegisteredTables(simpleTable.sdb, (table) => table !== scratch);
+    }
+}

package/esm/methods/upper.d.ts

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

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

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

package/esm/methods/upper.js

@@ -0,0 +1,14 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import stringToArray from "../helpers/stringToArray.js";
+import queueOp from "../helpers/queueOp.js";
+export default function upper(simpleTable, columns) {
+    const cols = stringToArray(columns);
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "upper()",
+        parameters: { columns },
+        needsSchema: false,
+        buildSelect: (input) => `SELECT * REPLACE (${cols.map((c) => `UPPER(${quoteIdentifier(c)}) AS ${quoteIdentifier(c)}`)
+            .join(", ")}) FROM ${input}`,
+    });
+}

package/esm/methods/wider.d.ts

@@ -0,0 +1,5 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function wider(simpleTable: SimpleTable, namesFrom: string, valuesFrom: string, options?: {
+    stat?: "sum" | "count" | "min" | "max" | "mean" | "median" | "first";
+}): void;
+//# sourceMappingURL=wider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wider.d.ts","sourceRoot":"","sources":["../../src/methods/wider.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,KAAK,CAC3B,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE;IACP,IAAI,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;CACjE,QA4BP"}

package/esm/methods/wider.js

@@ -0,0 +1,23 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import queueOp from "../helpers/queueOp.js";
+export default function wider(simpleTable, namesFrom, valuesFrom, options = {}) {
+    const stat = options.stat ?? "sum";
+    const aggregateFunction = stat === "mean" ? "avg" : stat;
+    // DuckDB rewrites PIVOT into multiple statements internally, so it can't
+    // be part of a fused chain: it executes as a barrier.
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "barrier",
+        method: "wider()",
+        parameters: { namesFrom, valuesFrom, options },
+        execute: async () => {
+            await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(simpleTable.name)} AS SELECT * FROM (PIVOT ${quoteIdentifier(simpleTable.name)} ON ${quoteIdentifier(namesFrom)} USING ${aggregateFunction}(${quoteIdentifier(valuesFrom)}));`, mergeOptions(simpleTable, {
+                table: simpleTable.name,
+                method: "wider()",
+                parameters: { namesFrom, valuesFrom, options },
+            }));
+        },
+    });
+}

package/esm/methods/writeDB.d.ts

@@ -0,0 +1,6 @@
+import type SimpleDB from "../class/SimpleDB.js";
+export default function writeDB(sdb: SimpleDB, file: string, options?: {
+    overwrite?: boolean;
+    metadata?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=writeDB.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writeDB.d.ts","sourceRoot":"","sources":["../../src/methods/writeDB.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AAYjD,wBAA8B,OAAO,CACnC,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,iBAwF1D"}