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

package/script/methods/createVssIndex.js

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

package/script/methods/crossJoin.d.ts

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

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

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

package/script/methods/crossJoin.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = crossJoin;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const getIdenticalColumns_js_1 = __importDefault(require("../helpers/getIdenticalColumns.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 assertSameDatabase_js_1 = __importDefault(require("../helpers/assertSameDatabase.js"));
+function crossJoin(simpleTable, rightTable, options = {}) {
+    (0, assertSameDatabase_js_1.default)(simpleTable.sdb, [rightTable], "crossJoin()");
+    options = structuredClone(options);
+    options.outputTable = (0, resolveOutputTable_js_1.default)(simpleTable, options.outputTable);
+    // The output table instance is created at call time so it can be returned
+    // synchronously and chained on right away.
+    const outputTable = typeof options.outputTable === "string"
+        ? simpleTable.sdb.newTable(options.outputTable)
+        : simpleTable;
+    (0, queueOp_js_1.default)(outputTable, {
+        kind: "barrier",
+        method: "crossJoin()",
+        parameters: { rightTable: rightTable.name, options },
+        execute: () => executeCrossJoin(simpleTable, rightTable, outputTable),
+    });
+    return outputTable;
+}
+async function executeCrossJoin(simpleTable, rightTable, outputTable) {
+    const identicalColumns = (0, getIdenticalColumns_js_1.default)(await simpleTable.getColumns(), await rightTable.getColumns());
+    if (identicalColumns.length > 0) {
+        throw new Error(`The tables have columns with identical names. Rename or remove ${identicalColumns.map((d) => `${(0, quoteIdentifier_js_1.default)(d)}`).join(", ")} in one of the two tables before doing the cross join.`);
+    }
+    await (0, queryDB_js_1.default)(simpleTable, `CREATE OR REPLACE TABLE ${(0, quoteIdentifier_js_1.default)(outputTable.name)} AS SELECT ${(0, quoteIdentifier_js_1.default)(simpleTable.name)}.*, ${(0, quoteIdentifier_js_1.default)(rightTable.name)}.* FROM ${(0, quoteIdentifier_js_1.default)(simpleTable.name)} CROSS JOIN ${(0, quoteIdentifier_js_1.default)(rightTable.name)};`, (0, mergeOptions_js_1.default)(simpleTable, {
+        table: outputTable.name,
+        method: "crossJoin()",
+        parameters: { rightTable: rightTable.name },
+    }));
+}

package/script/methods/difference.d.ts

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

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

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

package/script/methods/difference.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 = difference;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function difference(simpleTable, column1, column2, newColumn) {
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "difference()",
+        parameters: { column1, column2, newColumn },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            // The schema type carries the projection (e.g. GEOMETRY('EPSG:4326')),
+            // so the cast keeps it on the new geometries.
+            const expression = `ST_Difference(${(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/distance.d.ts

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

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

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

package/script/methods/distance.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = distance;
+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 distance(simpleTable, column1, column2, newColumn, options = {}) {
+    // Building the expression doesn't need the database, so invalid options
+    // throw at call time.
+    const expression = distanceExpression(column1, column2, options);
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "distance()",
+        parameters: { column1, column2, newColumn },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            (0, assertNewColumns_js_1.default)(types, [newColumn], "distance()");
+            return `SELECT *, CAST(${expression} AS DOUBLE) AS ${(0, quoteIdentifier_js_1.default)(newColumn)} FROM ${input}`;
+        },
+    });
+}
+function distanceExpression(column1, column2, options = {}) {
+    options = structuredClone(options);
+    options.method = options.method ?? "srs";
+    if (options.method === "srs" && typeof options.unit === "string") {
+        throw new Error("Using the SRS unit. You can't specify options.unit unless you set options.method to 'spheroid' or 'haversine'.");
+    }
+    else if (["spheroid", "haversine"].includes(options.method)) {
+        options.unit = options.unit ?? "m";
+        if (!["m", "km"].includes(options.unit)) {
+            throw new Error(`Unknown unit ${options.unit}. Choose between 'm' and 'km'.`);
+        }
+    }
+    let expression = "";
+    if (options.method === "srs") {
+        expression = `ST_Distance(${(0, quoteIdentifier_js_1.default)(column1)}, ${(0, quoteIdentifier_js_1.default)(column2)})`;
+    }
+    else if (options.method === "haversine") {
+        expression = `ST_Distance_Sphere(${(0, quoteIdentifier_js_1.default)(column1)}, ${(0, quoteIdentifier_js_1.default)(column2)}) ${options.unit === "km" ? "/ 1000" : ""}`;
+    }
+    else if (options.method === "spheroid") {
+        expression = `ST_Distance_Spheroid(${(0, quoteIdentifier_js_1.default)(column1)}::GEOMETRY, ${(0, quoteIdentifier_js_1.default)(column2)}::GEOMETRY) ${options.unit === "km" ? "/ 1000" : ""}`;
+    }
+    else {
+        throw new Error(`distance() received an unknown method: ${options.method}. Choose "srs", "haversine", or "spheroid".`);
+    }
+    return typeof options.decimals === "number"
+        ? `ROUND(${expression}, ${options.decimals})`
+        : expression;
+}

package/script/methods/extractDatePart.d.ts

@@ -0,0 +1,7 @@
+import type SimpleTable from "../class/SimpleTable.js";
+type DatePart = "year" | "quarter" | "month" | "week" | "day" | "dayOfWeek" | "dayOfYear" | "hour" | "minute" | "second";
+export default function extractDatePart(simpleTable: SimpleTable, column: string, parts: DatePart | {
+    [newColumn: string]: DatePart;
+}): void;
+export {};
+//# sourceMappingURL=extractDatePart.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extractDatePart.d.ts","sourceRoot":"","sources":["../../src/methods/extractDatePart.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAKvD,KAAK,QAAQ,GACT,MAAM,GACN,SAAS,GACT,OAAO,GACP,MAAM,GACN,KAAK,GACL,WAAW,GACX,WAAW,GACX,MAAM,GACN,QAAQ,GACR,QAAQ,CAAC;AAeb,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,QAAQ,GAAG;IAAE,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,QAiCpD"}

package/script/methods/extractDatePart.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = extractDatePart;
+const assertNewColumns_js_1 = __importDefault(require("../helpers/assertNewColumns.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const sqlParts = {
+    year: "year",
+    quarter: "quarter",
+    month: "month",
+    week: "week",
+    day: "day",
+    dayOfWeek: "dayofweek",
+    dayOfYear: "dayofyear",
+    hour: "hour",
+    minute: "minute",
+    second: "second",
+};
+function extractDatePart(simpleTable, column, parts) {
+    const capturedParts = typeof parts === "string"
+        ? parts
+        : structuredClone(parts);
+    const entries = typeof capturedParts === "string"
+        ? [[capturedParts, capturedParts]]
+        : Object.entries(capturedParts);
+    if (entries.length === 0) {
+        throw new Error("extractDatePart() requires at least one date part.");
+    }
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "extractDatePart()",
+        parameters: { column, parts: capturedParts },
+        needsSchema: true,
+        buildSelect: (input, schema) => {
+            (0, assertNewColumns_js_1.default)(schema, entries.map(([newColumn]) => newColumn), "extractDatePart()");
+            const source = (0, quoteIdentifier_js_1.default)(column);
+            const extractions = entries.map(([newColumn, part]) => `date_part('${sqlParts[part]}', ${source}) AS ${(0, quoteIdentifier_js_1.default)(newColumn)}`);
+            return `SELECT *, ${extractions.join(", ")} FROM ${input}`;
+        },
+    });
+}

package/script/methods/extractLatLon.d.ts

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

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

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

package/script/methods/extractLatLon.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = extractLatLon;
+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 extractLatLon(simpleTable, column, latColumn, lonColumn) {
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "extractLatLon()",
+        parameters: { column, latColumn, lonColumn },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            (0, assertNewColumns_js_1.default)(types, [latColumn, lonColumn], "extractLatLon()");
+            return `SELECT *, CAST(ST_Y(${(0, quoteIdentifier_js_1.default)(column)}) AS DOUBLE) AS ${(0, quoteIdentifier_js_1.default)(latColumn)}, CAST(ST_X(${(0, quoteIdentifier_js_1.default)(column)}) AS DOUBLE) AS ${(0, quoteIdentifier_js_1.default)(lonColumn)} FROM ${input}`;
+        },
+    });
+}

package/script/methods/fill.d.ts

@@ -1,7 +1,7 @@
 import type SimpleTable from "../class/SimpleTable.js";
 export default function fill(simpleTable: SimpleTable, columns: string | string[], options?: {
-    categories?: string | string[];
+    by?: string | string[];
     interpolate?: boolean;
     interpolateBy?: string;
-}): Promise<void>;
+}): void;
 //# sourceMappingURL=fill.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fill.d.ts","sourceRoot":"","sources":["../../src/methods/fill.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,IAAI,CAChC,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAC1B,OAAO,GAAE;IACP,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC/B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;CACnB,iBAmFP"}
+{"version":3,"file":"fill.d.ts","sourceRoot":"","sources":["../../src/methods/fill.ts"],"names":[],"mappings":"AAKA,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,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;CACnB,QAmBP"}

package/script/methods/fill.js

@@ -4,63 +4,60 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = fill;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.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 stringToArray_js_1 = __importDefault(require("../helpers/stringToArray.js"));
-async function fill(simpleTable, columns, options = {}) {
-    const categories = options.categories
-        ? (0, stringToArray_js_1.default)(options.categories)
-        : [];
-    const tempRowCol = `rowNumberForFill`;
+function fill(simpleTable, columns, options = {}) {
+    // This validation doesn't need the database, so it stays at call time.
     if (options.interpolateBy && options.interpolate === false) {
         throw new Error(`interpolate cannot be false when interpolateBy is set.`);
     }
+    // The fill order is based on rowid, which only exists on the materialized
+    // table: it executes as a barrier.
+    columns = Array.isArray(columns) ? [...columns] : columns;
+    options = structuredClone(options);
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "barrier",
+        method: "fill()",
+        parameters: { columns, options },
+        execute: () => executeFill(simpleTable, columns, options),
+    });
+}
+async function executeFill(simpleTable, columns, options) {
+    const by = options.by ? (0, stringToArray_js_1.default)(options.by) : [];
+    const cols = (0, stringToArray_js_1.default)(columns);
+    const excludeList = cols.map((col) => `${(0, quoteIdentifier_js_1.default)(col)}`).join(", ");
+    let selectList;
     if (options.interpolate || options.interpolateBy) {
-        const cols = (0, stringToArray_js_1.default)(columns);
-        // Always add temp row number to preserve original row order in output
-        await simpleTable.addRowNumber(tempRowCol);
-        // Use interpolateBy for the window function's ORDER BY (correct interpolation math),
-        // but always order final output by tempRowCol to preserve input row order
-        const windowOrderCol = options.interpolateBy ?? tempRowCol;
-        const excludeList = [`"${tempRowCol}"`, ...cols].join(", ");
-        const overClause = categories.length > 0
-            ? `(PARTITION BY ${categories.map((d) => `"${d}"`).join(", ")})`
+        // Use interpolateBy for the window function's ORDER BY (correct
+        // interpolation math), but always order the final output by rowid to
+        // preserve input row order.
+        const windowOrder = options.interpolateBy
+            ? `${(0, quoteIdentifier_js_1.default)(options.interpolateBy)}`
+            : "rowid";
+        const overClause = by.length > 0
+            ? `(PARTITION BY ${by.map((d) => `${(0, quoteIdentifier_js_1.default)(d)}`).join(", ")})`
             : `()`;
-        const selectList = cols
-            .map((col) => `fill(${col} ORDER BY "${windowOrderCol}") OVER ${overClause} as ${col}`)
+        selectList = cols
+            .map((col) => `fill(${(0, quoteIdentifier_js_1.default)(col)} ORDER BY ${windowOrder}) OVER ${overClause} as ${(0, quoteIdentifier_js_1.default)(col)}`)
             .join(", ");
-        await (0, queryDB_js_1.default)(simpleTable, `CREATE OR REPLACE TABLE "${simpleTable.name}" AS SELECT * EXCLUDE(${excludeList}), ${selectList} FROM "${simpleTable.name}" ORDER BY "${tempRowCol}";`, (0, mergeOptions_js_1.default)(simpleTable, {
-            table: simpleTable.name,
-            method: "fill()",
-            parameters: { columns, ...options },
-        }));
     }
-    else if (categories.length > 0) {
-        const partition = `PARTITION BY ${categories.map((d) => `"${d}"`).join(", ")}`;
-        await simpleTable.addRowNumber(tempRowCol);
-        const cols = (0, stringToArray_js_1.default)(columns);
-        const excludeList = [`"${tempRowCol}"`, ...cols].join(", ");
-        const selectList = cols
-            .map((col) => `COALESCE(${col}, LAG(${col} IGNORE NULLS) OVER(${partition} ORDER BY "${tempRowCol}")) as ${col}`)
+    else if (by.length > 0) {
+        const partition = `PARTITION BY ${by.map((d) => `${(0, quoteIdentifier_js_1.default)(d)}`).join(", ")}`;
+        selectList = cols
+            .map((col) => `COALESCE(${(0, quoteIdentifier_js_1.default)(col)}, LAG(${(0, quoteIdentifier_js_1.default)(col)} IGNORE NULLS) OVER(${partition} ORDER BY rowid)) as ${(0, quoteIdentifier_js_1.default)(col)}`)
             .join(", ");
-        await (0, queryDB_js_1.default)(simpleTable, `CREATE OR REPLACE TABLE "${simpleTable.name}" AS SELECT * EXCLUDE(${excludeList}), ${selectList} FROM "${simpleTable.name}" ORDER BY "${tempRowCol}";`, (0, mergeOptions_js_1.default)(simpleTable, {
-            table: simpleTable.name,
-            method: "fill()",
-            parameters: { columns, ...options },
-        }));
     }
     else {
-        // Simple path: add temp row number and order by it to preserve input row order
-        await simpleTable.addRowNumber(tempRowCol);
-        const cols = (0, stringToArray_js_1.default)(columns);
-        const excludeList = [`"${tempRowCol}"`, ...cols].join(", ");
-        const selectList = cols
-            .map((col) => `COALESCE(${col}, LAG(${col} IGNORE NULLS) OVER()) as ${col}`)
+        selectList = cols
+            .map((col) => `COALESCE(${(0, quoteIdentifier_js_1.default)(col)}, LAG(${(0, quoteIdentifier_js_1.default)(col)} IGNORE NULLS) OVER(ORDER BY rowid)) as ${(0, quoteIdentifier_js_1.default)(col)}`)
             .join(", ");
-        await (0, queryDB_js_1.default)(simpleTable, `CREATE OR REPLACE TABLE "${simpleTable.name}" AS SELECT * EXCLUDE(${excludeList}), ${selectList} FROM "${simpleTable.name}" ORDER BY "${tempRowCol}";`, (0, mergeOptions_js_1.default)(simpleTable, {
-            table: simpleTable.name,
-            method: "fill()",
-            parameters: { columns, ...options },
-        }));
     }
+    await (0, queryDB_js_1.default)(simpleTable, `CREATE OR REPLACE TABLE ${(0, quoteIdentifier_js_1.default)(simpleTable.name)} AS SELECT * EXCLUDE(${excludeList}), ${selectList} FROM ${(0, quoteIdentifier_js_1.default)(simpleTable.name)} ORDER BY rowid;`, (0, mergeOptions_js_1.default)(simpleTable, {
+        table: simpleTable.name,
+        method: "fill()",
+        parameters: { columns, ...options },
+    }));
 }

package/script/methods/fillHoles.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"fillHoles.d.ts","sourceRoot":"","sources":["../../src/methods/fillHoles.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,QAkBhB"}

package/script/methods/fillHoles.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 = fillHoles;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const findGeoColumnFromSchema_js_1 = __importDefault(require("../helpers/findGeoColumnFromSchema.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function fillHoles(simpleTable, column) {
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "fillHoles()",
+        parameters: { column },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            const col = column ??
+                (0, findGeoColumnFromSchema_js_1.default)(types, "fillHoles()", simpleTable.name);
+            // Like the previous UPDATE-based implementation, the result is always
+            // stored in the "geom" column, and the assignment cast keeps its type.
+            return `SELECT * REPLACE (ST_MakePolygon(ST_ExteriorRing(${(0, quoteIdentifier_js_1.default)(col)}))${types["geom"] ? `::${types["geom"]}` : ""} AS "geom") FROM ${input}`;
+        },
+    });
+}

package/script/methods/filter.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/methods/filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,MAAM,CAAC,OAAO,UAAU,MAAM,CAC5B,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,QAcnB"}

package/script/methods/filter.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = filter;
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function filter(simpleTable, conditions) {
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "filter()",
+        parameters: { conditions },
+        needsSchema: false,
+        rawSQL: [conditions],
+        preservesSchema: true,
+        buildSelect: (input) => `SELECT *
+        FROM ${input}
+        WHERE ${conditions}`,
+    });
+}

package/script/methods/firstChars.d.ts

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

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

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

package/script/methods/firstChars.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 = firstChars;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function firstChars(simpleTable, column, count) {
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "firstChars()",
+        parameters: { column, count },
+        needsSchema: false,
+        buildSelect: (input) => `SELECT * REPLACE (LEFT(${(0, quoteIdentifier_js_1.default)(column)}, ${count}) AS ${(0, quoteIdentifier_js_1.default)(column)}) FROM ${input}`,
+    });
+}

package/script/methods/fixGeo.d.ts

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

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

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

package/script/methods/fixGeo.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = fixGeo;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const findGeoColumnFromSchema_js_1 = __importDefault(require("../helpers/findGeoColumnFromSchema.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function fixGeo(simpleTable, column) {
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "fixGeo()",
+        parameters: { column },
+        needsSchema: true,
+        needsSpatial: true,
+        // The cast pins the geometry column back to its existing type, so the
+        // schema is unchanged.
+        preservesSchema: true,
+        buildSelect: (input, types) => {
+            const col = column ??
+                (0, findGeoColumnFromSchema_js_1.default)(types, "fixGeo()", simpleTable.name);
+            // The schema type carries the projection (e.g. GEOMETRY('EPSG:4326')),
+            // so the cast keeps it on the new geometries.
+            return `SELECT * REPLACE (ST_MakeValid(${(0, quoteIdentifier_js_1.default)(col)})::${types[col]} AS ${(0, quoteIdentifier_js_1.default)(col)}) FROM ${input}`;
+        },
+    });
+}

package/script/methods/flipCoordinates.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"flipCoordinates.d.ts","sourceRoot":"","sources":["../../src/methods/flipCoordinates.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,QAqBhB"}

package/script/methods/flipCoordinates.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = flipCoordinates;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const findGeoColumnFromSchema_js_1 = __importDefault(require("../helpers/findGeoColumnFromSchema.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+function flipCoordinates(simpleTable, column) {
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "flipCoordinates()",
+        parameters: { column },
+        needsSchema: true,
+        needsSpatial: true,
+        // The cast pins the geometry column back to its existing type, so the
+        // schema is unchanged.
+        preservesSchema: true,
+        buildSelect: (input, types) => {
+            const col = column ??
+                (0, findGeoColumnFromSchema_js_1.default)(types, "flipCoordinates()", simpleTable.name);
+            // The schema type carries the projection (e.g. GEOMETRY('EPSG:4326')),
+            // so the cast keeps it on the new geometries.
+            return `SELECT * REPLACE (ST_FlipCoordinates(${(0, quoteIdentifier_js_1.default)(col)})::${types[col]} AS ${(0, quoteIdentifier_js_1.default)(col)}) FROM ${input}`;
+        },
+    });
+}