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

package/script/methods/cache.js

@@ -1,4 +1,37 @@
 "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 };
 };
@@ -6,11 +39,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = cache;
 const node_fs_1 = require("node:fs");
 const node_crypto_1 = __importDefault(require("node:crypto"));
-const formatDate_js_1 = __importDefault(require("../helpers/formatDate.js"));
+const flushAllTables_js_1 = __importDefault(require("../helpers/flushAllTables.js"));
 const prettyDuration_js_1 = __importDefault(require("../helpers/prettyDuration.js"));
-async function cache(table, run, options = {}) {
+const cacheDiagnostics_js_1 = require("../helpers/cacheDiagnostics.js");
+const serializeCacheInputs_js_1 = __importStar(require("../helpers/serializeCacheInputs.js"));
+const tableGeneration_js_1 = require("../helpers/tableGeneration.js");
+const cacheDatabase_js_1 = require("../helpers/cacheDatabase.js");
+const cacheTableDependencies_js_1 = require("../helpers/cacheTableDependencies.js");
+const CACHE_FORMAT_VERSION = "duckdb-v4";
+async function cache(table, compute, options = {}) {
+    // If cache() is itself called from another cache computation, the outer
+    // computation depends on the table produced here.
+    (0, cacheTableDependencies_js_1.recordCacheTableAccess)(table);
     options.verbose &&
         console.log(`\ncache() for ${table.name}`);
+    // cache() is an observation point even when a cache hit has no artifact to
+    // load, so all earlier database-wide work must complete before it returns.
+    await (0, flushAllTables_js_1.default)(table.sdb);
     const cachePath = "./.sda-cache";
     if (!(0, node_fs_1.existsSync)(cachePath)) {
         (0, node_fs_1.mkdirSync)(cachePath);
@@ -20,70 +65,107 @@ async function cache(table, run, options = {}) {
     if ((0, node_fs_1.existsSync)(cacheSourcesPath)) {
         cacheSources = JSON.parse((0, node_fs_1.readFileSync)(cacheSourcesPath, "utf-8"));
     }
-    const functionBody = run.toString();
-    const hash = node_crypto_1.default
-        .createHash("sha256")
-        .update(table.name + options.toString() + functionBody)
-        .digest("hex");
-    const id = `${table.name}.${hash}`;
-    const cache = cacheSources[id];
+    const functionBody = compute.toString();
+    const entryGeneration = (0, tableGeneration_js_1.peekTableGeneration)(table) ?? null;
+    const inputs = options.inputs?.filter((input) => input !== table) ?? [];
+    const hasInputs = inputs.length > 0;
+    const serializedInputs = hasInputs ? (0, serializeCacheInputs_js_1.default)(inputs) : null;
+    const codeHash = createHash(functionBody);
+    const inputHashes = hasInputs
+        ? inputs.map((input) => createHash((0, serializeCacheInputs_js_1.default)([input])))
+        : [];
+    const hash = createHash(JSON.stringify([
+        CACHE_FORMAT_VERSION,
+        table.name,
+        entryGeneration,
+        functionBody,
+        serializedInputs,
+    ]));
+    const requestedId = `${table.name}.${hash}`;
+    let id = requestedId;
+    let cache = cacheSources[id];
+    if (cache === undefined) {
+        const alreadyApplied = findAlreadyAppliedCache(table, cacheSources, entryGeneration, codeHash, inputHashes);
+        if (alreadyApplied !== undefined) {
+            [id, cache] = alreadyApplied;
+        }
+    }
+    if (cache !== undefined &&
+        !(0, cacheTableDependencies_js_1.cacheTableDependenciesMatch)(table, cache.tableDependencies)) {
+        cache = undefined;
+    }
     const now = Date.now();
+    if (cache !== undefined) {
+        ensureCacheDiagnostics(cache, cacheSources, cacheSourcesPath, codeHash, inputHashes);
+    }
     if (cache === undefined) {
-        options.verbose &&
-            console.log(`Nothing in cache. Running and storing in cache.`);
-        await runAndWrite(table, run, cacheSources, cacheSourcesPath, cachePath, id);
+        if (options.verbose) {
+            logCacheMiss(table, cacheSources, codeHash, inputHashes, inputs, entryGeneration);
+        }
+        await runAndWrite(table, compute, cacheSources, cacheSourcesPath, cachePath, id, codeHash, inputHashes, entryGeneration);
     }
-    else if (cache &&
-        typeof options.ttl === "number" &&
-        now - cache.creation > options.ttl * 1000) {
+    else if (options.ttl !== undefined &&
+        (0, cacheDiagnostics_js_1.cacheEntryExpired)(cache.creation, options.ttl, now)) {
+        const refreshId = cache.entryGeneration === entryGeneration
+            ? id
+            : requestedId;
         options.verbose &&
-            console.log(`Found in cache.\nttl of ${(0, prettyDuration_js_1.default)(0, { end: options.ttl * 1000 })} has expired.\nThe creation date is ${(0, formatDate_js_1.default)(new Date(cache.creation), "Month DD, YYYY, at HH:MM period")}.\nIt's is ${(0, prettyDuration_js_1.default)(cache.creation, { end: now })} ago.\nRunning and storing in cache.`);
-        await runAndWrite(table, run, cacheSources, cacheSourcesPath, cachePath, id);
+            console.log(`Cache entry is stale.\n${identityMatchMessage(inputHashes, cache.tableDependencies ?? [])}\n${(0, cacheDiagnostics_js_1.cacheTtlMessage)(cache.creation, options.ttl, now, true)}\nRunning computations and refreshing the cache entry.`);
+        await runAndWrite(table, compute, cacheSources, cacheSourcesPath, cachePath, refreshId, codeHash, inputHashes, entryGeneration);
     }
     else {
         options.verbose &&
-            console.log(`Found in cache.`);
+            console.log(`Cache hit.\n${identityMatchMessage(inputHashes, cache.tableDependencies ?? [])}`);
         if (typeof options.ttl === "number") {
-            const ttlLimit = new Date(cache.creation + options.ttl * 1000);
             (options.verbose) &&
-                console.log(`ttl of ${(0, prettyDuration_js_1.default)(0, { end: options.ttl * 1000 })} has not expired.\nThe creation date is ${(0, formatDate_js_1.default)(new Date(cache.creation), "Month DD, YYYY, at HH:MM period")}.\nThere are ${(0, prettyDuration_js_1.default)(now, { end: ttlLimit })} left.`);
+                console.log((0, cacheDiagnostics_js_1.cacheTtlMessage)(cache.creation, options.ttl, now, false));
         }
         if (cache.file === null) {
             console.log("No data in cache. Nothing to load.");
         }
-        else if (cache.geo) {
+        else {
             const start = Date.now();
-            await table.loadGeoData(cache.file);
-            if (table.sdb.cacheSourcesUsed.indexOf(id) < 0) {
-                table.sdb.cacheSourcesUsed.push(id);
+            try {
+                await (0, cacheDatabase_js_1.loadCacheDatabase)(table, cache.file, cache.indexes ?? [], cache.geo);
             }
-            const end = Date.now();
-            const duration = end - start;
-            if (options.verbose) {
-                console.log(`Data loaded in ${(0, prettyDuration_js_1.default)(start, { end })}.\nRunning computations previously took ${(0, prettyDuration_js_1.default)(0, { end: cache.duration })}.\nYou saved ${(0, prettyDuration_js_1.default)(duration, { end: cache.duration })}.\n`);
-                table.sdb.cacheTimeSaved += cache.duration - duration;
+            catch {
+                options.verbose &&
+                    console.log("Could not load cached data. Recomputing...");
+                if ((0, node_fs_1.existsSync)(cache.file)) {
+                    (0, node_fs_1.rmSync)(cache.file);
+                }
+                delete cacheSources[id];
+                await runAndWrite(table, compute, cacheSources, cacheSourcesPath, cachePath, requestedId, codeHash, inputHashes, entryGeneration);
+                return;
             }
-        }
-        else {
-            const start = Date.now();
-            await table.loadData(cache.file);
             if (table.sdb.cacheSourcesUsed.indexOf(id) < 0) {
                 table.sdb.cacheSourcesUsed.push(id);
             }
             const end = Date.now();
             const duration = end - start;
             if (options.verbose) {
-                console.log(`Data loaded in ${(0, prettyDuration_js_1.default)(start, { end })}.\nRunning computations previously took ${(0, prettyDuration_js_1.default)(0, { end: cache.duration })}.\nYou saved ${(0, prettyDuration_js_1.default)(duration, { end: cache.duration })}.\n`);
+                console.log(`${(0, cacheDiagnostics_js_1.cacheLoadMessage)(start, end, cache.duration)}\n`);
                 table.sdb.cacheTimeSaved += cache.duration - duration;
             }
         }
+        restoreCachedGeneration(table, cache, cacheSources, cacheSourcesPath);
     }
 }
-async function runAndWrite(table, run, cacheSources, cacheSourcesPath, cachePath, id) {
+async function runAndWrite(table, compute, cacheSources, cacheSourcesPath, cachePath, id, codeHash, inputHashes, entryGeneration) {
+    // Complete any work queued before cache() before dependency observation
+    // begins. Operations queued by compute are flushed inside the observation.
+    await (0, flushAllTables_js_1.default)(table.sdb);
     const start = Date.now();
-    await run();
+    const tableDependencies = await (0, cacheTableDependencies_js_1.captureCacheTableDependencies)(table, async () => {
+        await compute(table);
+        // run() only queues the sync builders in the user's callback; the actual
+        // computation happens at the flush, so it must be included in the timing
+        // that decides how much the cache saves on later hits.
+        await (0, flushAllTables_js_1.default)(table.sdb);
+    });
     const end = Date.now();
     const duration = end - start;
+    const generationId = (0, tableGeneration_js_1.createTableGenerationId)();
     table.sdb.cacheVerbose &&
         console.log(`Computations done in ${(0, prettyDuration_js_1.default)(start, { end })}.`);
     if (!(await table.sdb.hasTable(table.name))) {
@@ -93,47 +175,155 @@ async function runAndWrite(table, run, cacheSources, cacheSourcesPath, cachePath
             duration,
             file: null,
             geo: false,
+            entryGeneration,
+            generationId,
+            indexes: [],
+            formatVersion: CACHE_FORMAT_VERSION,
+            codeHash,
+            inputHashes,
+            tableDependencies,
         };
     }
     else {
         const types = await table.getTypes();
         const geometriesColumns = Object.values(types).filter((d) => d.toLowerCase().includes("geometry")).length;
-        if (geometriesColumns > 0) {
-            const file = `${cachePath}/${id}.geoparquet`;
-            const writeStart = Date.now();
-            await table.writeGeoData(file);
-            cacheSources[id] = {
-                creation: Date.now(),
-                duration,
-                file,
-                geo: true,
-            };
-            const writeEnd = Date.now();
-            table.sdb.cacheVerbose &&
-                console.log(`Wrote in cache in ${(0, prettyDuration_js_1.default)(writeStart, { end: writeEnd })}.\n`);
-            table.sdb.cacheTimeWriting += writeEnd - writeStart;
-            if (table.sdb.cacheSourcesUsed.indexOf(id) < 0) {
-                table.sdb.cacheSourcesUsed.push(id);
-            }
+        const file = `${cachePath}/${id}.db`;
+        const indexes = structuredClone(table.indexes);
+        const writeStart = Date.now();
+        await (0, cacheDatabase_js_1.writeCacheDatabase)(table, file, indexes);
+        const writeEnd = Date.now();
+        table.sdb.cacheVerbose &&
+            console.log(`Wrote in cache in ${(0, prettyDuration_js_1.default)(writeStart, { end: writeEnd })}.\n`);
+        table.sdb.cacheTimeWriting += writeEnd - writeStart;
+        cacheSources[id] = {
+            creation: Date.now(),
+            duration,
+            file,
+            geo: geometriesColumns > 0,
+            entryGeneration,
+            generationId,
+            indexes,
+            formatVersion: CACHE_FORMAT_VERSION,
+            codeHash,
+            inputHashes,
+            tableDependencies,
+        };
+        if (table.sdb.cacheSourcesUsed.indexOf(id) < 0) {
+            table.sdb.cacheSourcesUsed.push(id);
+        }
+    }
+    (0, node_fs_1.writeFileSync)(cacheSourcesPath, JSON.stringify(cacheSources));
+    (0, tableGeneration_js_1.restoreTableGeneration)(table, generationId);
+}
+function restoreCachedGeneration(table, cache, cacheSources, cacheSourcesPath) {
+    if (cache.generationId === undefined) {
+        cache.generationId = (0, tableGeneration_js_1.createTableGenerationId)();
+        (0, node_fs_1.writeFileSync)(cacheSourcesPath, JSON.stringify(cacheSources));
+    }
+    (0, tableGeneration_js_1.restoreTableGeneration)(table, cache.generationId);
+}
+function ensureCacheDiagnostics(cache, cacheSources, cacheSourcesPath, codeHash, inputHashes) {
+    if (cache.formatVersion === undefined || cache.codeHash === undefined ||
+        cache.inputHashes === undefined) {
+        cache.formatVersion = CACHE_FORMAT_VERSION;
+        cache.codeHash = codeHash;
+        cache.inputHashes = inputHashes;
+        (0, node_fs_1.writeFileSync)(cacheSourcesPath, JSON.stringify(cacheSources));
+    }
+}
+function createHash(value) {
+    return node_crypto_1.default.createHash("sha256").update(value).digest("hex");
+}
+function identityMatchMessage(inputHashes, tableDependencies) {
+    const inputsMessage = inputHashes.length === 0
+        ? "Compute function unchanged."
+        : `Compute function unchanged.\nInputs unchanged (${inputHashes.length} checked).`;
+    const dependenciesMessage = tableDependencies.length === 0
+        ? ""
+        : `\n${(0, cacheTableDependencies_js_1.unchangedCacheTableDependenciesMessage)(tableDependencies)}`;
+    return `${inputsMessage}${dependenciesMessage}`;
+}
+function findAlreadyAppliedCache(table, cacheSources, entryGeneration, codeHash, inputHashes) {
+    if (entryGeneration === null) {
+        return undefined;
+    }
+    return Object.entries(cacheSources)
+        .filter(([id, source]) => id.startsWith(`${table.name}.`) &&
+        source.formatVersion === CACHE_FORMAT_VERSION &&
+        source.generationId === entryGeneration &&
+        source.codeHash === codeHash &&
+        arraysEqual(source.inputHashes, inputHashes) &&
+        (0, cacheTableDependencies_js_1.cacheTableDependenciesMatch)(table, source.tableDependencies))
+        .reduce((latest, candidate) => latest === undefined || candidate[1].creation > latest[1].creation
+        ? candidate
+        : latest, undefined);
+}
+function arraysEqual(left, right) {
+    return left !== undefined && left.length === right.length &&
+        left.every((value, index) => value === right[index]);
+}
+function logCacheMiss(table, cacheSources, codeHash, inputHashes, inputs, entryGeneration) {
+    const candidates = Object.entries(cacheSources)
+        .filter(([id]) => id.startsWith(`${table.name}.`))
+        .map(([, source]) => source)
+        .filter(isCacheDiagnosticSource);
+    let reason;
+    if (candidates.length === 0) {
+        const hasLegacyCandidate = Object.keys(cacheSources).some((id) => id.startsWith(`${table.name}.`));
+        reason = hasLegacyCandidate
+            ? "A previous entry exists, but it predates detailed cache diagnostics. Its code, inputs, or cache format changed."
+            : "No matching cache entry exists for this computation.";
+    }
+    else {
+        const sameFormat = candidates.filter((source) => source.formatVersion === CACHE_FORMAT_VERSION);
+        const sameCode = latestCacheSource(sameFormat.filter((source) => source.codeHash === codeHash));
+        if (sameCode !== undefined) {
+            const inputsMessage = changedInputsMessage(sameCode.inputHashes, inputHashes, inputs);
+            const tableMessage = sameCode.entryGeneration === entryGeneration
+                ? ""
+                : "The current table has changed.";
+            const dependenciesMessage = (0, cacheTableDependencies_js_1.changedCacheTableDependenciesMessage)(table, sameCode.tableDependencies);
+            const changes = [tableMessage, inputsMessage, dependenciesMessage]
+                .filter((message) => message.length > 0);
+            reason = changes.length === 0
+                ? "Compute function unchanged."
+                : `Compute function unchanged.\n${changes.join("\n")}`;
+        }
+        else if (sameFormat.length === 0) {
+            reason = "The cache format changed.";
         }
         else {
-            const file = `${cachePath}/${id}.parquet`;
-            const writeStart = Date.now();
-            await table.writeData(file);
-            const writeEnd = Date.now();
-            table.sdb.cacheVerbose &&
-                console.log(`Wrote in cache in ${(0, prettyDuration_js_1.default)(writeStart, { end: writeEnd })}.\n`);
-            table.sdb.cacheTimeWriting += writeEnd - writeStart;
-            cacheSources[id] = {
-                creation: Date.now(),
-                duration,
-                file,
-                geo: false,
-            };
-            if (table.sdb.cacheSourcesUsed.indexOf(id) < 0) {
-                table.sdb.cacheSourcesUsed.push(id);
-            }
+            reason = "No matching cache entry exists for this computation.";
         }
     }
-    (0, node_fs_1.writeFileSync)(cacheSourcesPath, JSON.stringify(cacheSources));
+    console.log(`Cache miss.\n${reason}\nRunning computations and storing a new cache entry.`);
+}
+function latestCacheSource(cacheSources) {
+    return cacheSources.reduce((latest, source) => latest === undefined || source.creation > latest.creation
+        ? source
+        : latest, undefined);
+}
+function isCacheDiagnosticSource(source) {
+    return source.formatVersion !== undefined && source.codeHash !== undefined &&
+        source.inputHashes !== undefined && source.tableDependencies !== undefined;
+}
+function changedInputsMessage(previousHashes, inputHashes, inputs) {
+    const changes = [];
+    const sharedLength = Math.min(previousHashes.length, inputHashes.length);
+    for (let i = 0; i < sharedLength; i++) {
+        if (previousHashes[i] !== inputHashes[i]) {
+            changes.push(`${(0, serializeCacheInputs_js_1.getCacheInputLabel)(inputs[i]) ?? `inputs[${i}]`} changed`);
+        }
+    }
+    for (let i = sharedLength; i < inputHashes.length; i++) {
+        changes.push(`${(0, serializeCacheInputs_js_1.getCacheInputLabel)(inputs[i]) ?? `inputs[${i}]`} was added`);
+    }
+    for (let i = sharedLength; i < previousHashes.length; i++) {
+        changes.push(`inputs[${i}] was removed`);
+    }
+    return changes.length === 0
+        ? inputHashes.length === 0
+            ? ""
+            : `Inputs unchanged (${inputHashes.length} checked).`
+        : `Inputs changed: ${changes.join(", ")}.`;
 }

package/script/methods/capitalize.d.ts

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

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

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

package/script/methods/capitalize.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = capitalize;
+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 capitalize(simpleTable, columns) {
+    const cols = (0, stringToArray_js_1.default)(columns);
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "capitalize()",
+        parameters: { columns },
+        needsSchema: false,
+        buildSelect: (input) => `SELECT * REPLACE (${cols
+            .map((c) => `CONCAT(UPPER(LEFT(${(0, quoteIdentifier_js_1.default)(c)}, 1)), LOWER(RIGHT(${(0, quoteIdentifier_js_1.default)(c)}, LENGTH(${(0, quoteIdentifier_js_1.default)(c)})-1))) AS ${(0, quoteIdentifier_js_1.default)(c)}`)
+            .join(", ")}) FROM ${input}`,
+    });
+}

package/script/methods/centroid.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"centroid.d.ts","sourceRoot":"","sources":["../../src/methods/centroid.ts"],"names":[],"mappings":"AAGA,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,CAAA;CAAO,QA2BlC"}

package/script/methods/centroid.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = centroid;
+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 centroid(simpleTable, newColumn, options = {}) {
+    options = structuredClone(options);
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "centroid()",
+        parameters: { newColumn, options },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            const column = typeof options.column === "string"
+                ? options.column
+                : (0, findGeoColumnFromSchema_js_1.default)(types, "centroid()", simpleTable.name);
+            // The schema type carries the projection (e.g. GEOMETRY('EPSG:4326')),
+            // so the cast keeps it on the new geometries.
+            const expression = `ST_Centroid(${(0, quoteIdentifier_js_1.default)(column)})::${types[column]}`;
+            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/clone.d.ts

@@ -0,0 +1,9 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function clone(simpleTable: SimpleTable, nameOrOptions?: string | {
+    name?: string;
+    conditions?: string;
+    columns?: string | string[];
+    limit?: number;
+    offset?: number;
+}): SimpleTable;
+//# sourceMappingURL=clone.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clone.d.ts","sourceRoot":"","sources":["../../src/methods/clone.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,KAAK,CAC3B,WAAW,EAAE,WAAW,EACxB,aAAa,GAAE,MAAM,GAAG;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACZ,GACL,WAAW,CAuCb"}

package/script/methods/clone.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 = clone;
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+const stringToArray_js_1 = __importDefault(require("../helpers/stringToArray.js"));
+function clone(simpleTable, nameOrOptions = {}) {
+    const columns = typeof nameOrOptions === "object" && nameOrOptions.columns
+        ? (0, stringToArray_js_1.default)(nameOrOptions.columns)
+        : [];
+    // The cloned table instance is created at call time so it can be returned
+    // synchronously and chained on right away. Delegating to sdb.newTable()
+    // makes subclasses using tableClass work correctly.
+    let clonedTable;
+    const options = typeof nameOrOptions === "string"
+        ? { name: nameOrOptions }
+        : { ...nameOrOptions };
+    if (typeof options.name === "string") {
+        clonedTable = simpleTable.sdb.newTable(options.name);
+    }
+    else {
+        clonedTable = simpleTable.sdb.newTable(undefined);
+    }
+    const selectClause = columns.length > 0
+        ? columns.map((col) => `${(0, quoteIdentifier_js_1.default)(col)}`).join(", ")
+        : "*";
+    (0, queueOp_js_1.default)(clonedTable, {
+        kind: "source",
+        method: "clone()",
+        parameters: { options },
+        // The clone reads simpleTable by name rather than through clonedTable's
+        // own (nonexistent) chain, so simpleTable's pending work must close and
+        // execute before this SELECT runs, as it would at this call position.
+        rawSQL: [`${(0, quoteIdentifier_js_1.default)(simpleTable.name)}`],
+        buildSelect: () => `SELECT ${selectClause} FROM ${(0, quoteIdentifier_js_1.default)(simpleTable.name)}${options.conditions ? ` WHERE ${options.conditions}` : ""}${typeof options.limit === "number" ? ` LIMIT ${options.limit}` : ""}${typeof options.offset === "number" ? ` OFFSET ${options.offset}` : ""}`,
+    });
+    return clonedTable;
+}

package/script/methods/cloneColumn.d.ts

@@ -1,4 +1,3 @@
-export default function cloneColumnQuery(table: string, originalColumn: string, newColumn: string, types: {
-    [key: string]: string;
-}): string;
+import type SimpleTable from "../class/SimpleTable.js";
+export default function cloneColumn(simpleTable: SimpleTable, column: string, newColumn: string): void;
 //# sourceMappingURL=cloneColumn.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cloneColumn.d.ts","sourceRoot":"","sources":["../../src/methods/cloneColumn.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,gBAAgB,CACtC,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,UAejC"}
+{"version":3,"file":"cloneColumn.d.ts","sourceRoot":"","sources":["../../src/methods/cloneColumn.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,QAiBlB"}

package/script/methods/cloneColumn.js

@@ -1,16 +1,24 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = cloneColumnQuery;
-function cloneColumnQuery(table, originalColumn, newColumn, types) {
-    let query = "";
-    const originalColumnType = types[originalColumn];
-    if (originalColumnType) {
-        query +=
-            `ALTER TABLE "${table}" ADD COLUMN "${newColumn}" ${originalColumnType};
-        UPDATE "${table}" SET "${newColumn}" = "${originalColumn}"`;
-    }
-    else {
-        throw new Error(`Can't find type of ${originalColumn}`);
-    }
-    return query;
+exports.default = cloneColumn;
+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 cloneColumn(simpleTable, column, newColumn) {
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "fusable",
+        method: "cloneColumn()",
+        parameters: { column, newColumn },
+        needsSchema: true,
+        buildSelect: (input, types) => {
+            if (!types[column]) {
+                throw new Error(`Can't find type of ${column}`);
+            }
+            (0, assertNewColumns_js_1.default)(types, [newColumn], "cloneColumn()");
+            return `SELECT *, ${(0, quoteIdentifier_js_1.default)(column)} AS ${(0, quoteIdentifier_js_1.default)(newColumn)} FROM ${input}`;
+        },
+    });
 }

package/script/methods/cloneColumnWithOffset.d.ts

@@ -0,0 +1,6 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function cloneColumnWithOffset(simpleTable: SimpleTable, column: string, newColumn: string, options?: {
+    offset?: number;
+    by?: string | string[];
+}): void;
+//# sourceMappingURL=cloneColumnWithOffset.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloneColumnWithOffset.d.ts","sourceRoot":"","sources":["../../src/methods/cloneColumnWithOffset.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAC3C,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACnB,QAiDP"}

package/script/methods/cloneColumnWithOffset.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 = cloneColumnWithOffset;
+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"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+const stringToArray_js_1 = __importDefault(require("../helpers/stringToArray.js"));
+function cloneColumnWithOffset(simpleTable, column, newColumn, options = {}) {
+    // The offset is based on rowid, which only exists on the materialized
+    // table, not on the output of a fused step: it executes as a barrier.
+    options = structuredClone(options);
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "barrier",
+        method: "cloneColumnWithOffset()",
+        parameters: { column, newColumn, options },
+        execute: async () => {
+            // A SELECT *, expr AS col colliding with an existing column would be
+            // silently renamed by DuckDB (col -> col_1) instead of erroring.
+            (0, assertNewColumns_js_1.default)(await simpleTable.getTypes(), [newColumn], "cloneColumnWithOffset()");
+            const offset = options.offset ?? 1;
+            const by = options.by ? (0, stringToArray_js_1.default)(options.by) : [];
+            const partition = by.length > 0
+                ? `PARTITION BY ${by.map((d) => `${(0, quoteIdentifier_js_1.default)(d)}`).join(", ")}`
+                : "";
+            // When by are specified, also sort the final result by
+            // by.
+            await (0, queryDB_js_1.default)(simpleTable, `CREATE OR REPLACE TABLE ${(0, quoteIdentifier_js_1.default)(simpleTable.name)} AS SELECT *, LEAD(${(0, quoteIdentifier_js_1.default)(column)}, ${offset}) OVER(${partition} ORDER BY rowid) AS ${(0, quoteIdentifier_js_1.default)(newColumn)} FROM ${(0, quoteIdentifier_js_1.default)(simpleTable.name)}${by.length > 0
+                ? ` ORDER BY ${by.map((d) => `${(0, quoteIdentifier_js_1.default)(d)}`).join(", ")}, rowid`
+                : ` ORDER BY rowid`};`, (0, mergeOptions_js_1.default)(simpleTable, {
+                table: simpleTable.name,
+                method: "cloneColumnWithOffset()",
+                parameters: { column, newColumn },
+            }));
+        },
+    });
+}

package/script/methods/columnProportions.d.ts

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