@nshiab/simple-data-analysis-core 2.0.5 → 2.0.6

package/esm/helpers/updateColumnsWithJS.js

@@ -0,0 +1,139 @@
+import quoteIdentifier from "./quoteIdentifier.js";
+import readMutationRows from "./readMutationRows.js";
+import { retainRegisteredTables } from "./tableRegistry.js";
+import { executePreparedArray, prepareArray } from "../methods/loadArray.js";
+/**
+ * Generates columns from selected input columns, keeping other SQL values in
+ * DuckDB. Call from an asynchronous extension barrier. The callback must return
+ * one row per input row in the same order; only the declared output columns are
+ * stored. Existing output columns are replaced, with types inferred from the
+ * generated values. Generation runs sequentially in bounded batches (1,000 rows
+ * by default); callbacks must not depend on receiving the whole table. Non-null
+ * output types must agree across batches. All-null batches defer type inference.
+ * Only one batch of inputs and outputs is retained by this helper in JavaScript;
+ * callers must also bound their own buffering. Reads finish before callbacks or
+ * writes use the shared connection. The original table is replaced only after
+ * staging succeeds. Empty tables are unchanged and do not invoke the callback;
+ * outputs that remain null in every batch use VARCHAR.
+ *
+ * Untouched geometry columns remain in DuckDB, preserving their values, types
+ * and CRS without GeoJSON conversion. Geometry columns cannot be selected as
+ * inputs or overwritten as outputs; use updateWithJS() for editable GeoJSON.
+ * This SQL-only preservation path accepts any source CRS.
+ *
+ * @param table - Table to enrich.
+ * @param inputColumns - Columns available to the callback.
+ * @param outputColumns - Generated columns to add or replace.
+ * @param generate - Produces one result per input row, in input order.
+ * @param options - Controls the maximum rows read, generated, and staged at once.
+ * @returns Resolves after merging the generated columns into the table.
+ * @example
+ * ```ts
+ * queueAsyncBarrier(table, {
+ *   method: "label()",
+ *   parameters: null,
+ *   execute: () => updateColumnsWithJS(table, ["name"], ["label"], async (rows) =>
+ *     rows.map((row) => ({ label: String(row.name).toUpperCase() })),
+ *     { batchSize: 500 }),
+ * });
+ * await table.log();
+ * ```
+ */
+export default async function updateColumnsWithJS(table, inputColumns, outputColumns, generate, options = {}) {
+    const batchSize = options.batchSize ?? 1000;
+    if (!Number.isSafeInteger(batchSize) || batchSize < 1) {
+        throw new Error("batchSize must be a positive safe integer.");
+    }
+    if (inputColumns.length === 0 || outputColumns.length === 0) {
+        throw new Error("Input and output columns must not be empty.");
+    }
+    if (new Set(outputColumns.map((name) => name.toLowerCase())).size !==
+        outputColumns.length) {
+        throw new Error("Output columns must be unique.");
+    }
+    const types = await table.getTypes();
+    for (const [name, type] of Object.entries(types)) {
+        if (type.toUpperCase().startsWith("GEOMETRY") &&
+            [...inputColumns, ...outputColumns].some((column) => column.toLowerCase() === name.toLowerCase())) {
+            throw new Error(`Geometry column ${JSON.stringify(name)} cannot be an input or output of updateColumnsWithJS(); use updateWithJS() for editable GeoJSON.`);
+        }
+    }
+    const suffix = crypto.randomUUID().replaceAll("-", "");
+    const id = `__sda_id_${suffix}`;
+    const snapshot = `__sda_source_${suffix}`;
+    const staged = table.sdb.newTable(`__sda_generated_${suffix}`);
+    const batch = table.sdb.newTable(`__sda_batch_${suffix}`);
+    const q = quoteIdentifier;
+    try {
+        // A SQL snapshot gives every row a stable identity, including duplicate rows
+        // and user columns named rowid. No untouched values cross the JS boundary.
+        await table.sdb.customQuery(`CREATE TEMP TABLE ${q(snapshot)} AS SELECT *, row_number() OVER () AS ${q(id)} FROM ${q(table.name)}`);
+        const knownTypes = new Map();
+        let lastId = "0";
+        let hasRows = false;
+        while (true) {
+            const upperId = BigInt(lastId) + BigInt(batchSize);
+            const { rows } = await readMutationRows(table.connection, `SELECT ${q(id)}, ${inputColumns.map(q).join(", ")} FROM ${q(snapshot)} WHERE ${q(id)} > ${lastId} AND ${q(id)} <= ${upperId}
+        ORDER BY ${q(id)} LIMIT ${batchSize}`);
+            if (rows.length === 0)
+                break;
+            const ids = rows.map((row) => String(row[id]));
+            lastId = ids[ids.length - 1];
+            for (const row of rows)
+                delete row[id];
+            const generated = await generate(rows);
+            if (generated.length !== ids.length) {
+                throw new Error("Column generation must return one row per input row.");
+            }
+            // Generated vectors retain this helper's existing inference contract.
+            await executePreparedArray(batch, prepareArray(generated.map((row, i) => ({
+                ...Object.fromEntries(outputColumns.map((name) => [name, row[name]])),
+                [id]: ids[i],
+            }))));
+            const batchTypes = await batch.getTypes();
+            for (const name of outputColumns) {
+                const nonNull = generated.some((row) => row[name] !== null && row[name] !== undefined);
+                if (!nonNull)
+                    continue;
+                const previous = knownTypes.get(name);
+                const current = batchTypes[name];
+                if (previous !== undefined && previous !== current) {
+                    throw new Error(`Generated column ${JSON.stringify(name)} changed type from ${previous} to ${current}.`);
+                }
+                if (previous === undefined) {
+                    knownTypes.set(name, current);
+                    if (hasRows) {
+                        await table.sdb.customQuery(`ALTER TABLE ${q(staged.name)} ALTER COLUMN ${q(name)} TYPE ${current} USING NULL`);
+                    }
+                }
+            }
+            if (!hasRows) {
+                await table.sdb.customQuery(`CREATE TEMP TABLE ${q(staged.name)} AS SELECT * FROM ${q(batch.name)}`);
+                hasRows = true;
+            }
+            else {
+                await table.sdb.customQuery(`INSERT INTO ${q(staged.name)} SELECT * FROM ${q(batch.name)}`);
+            }
+        }
+        if (!hasRows)
+            return;
+        const outputs = new Map(outputColumns.map((name) => [name.toLowerCase(), name]));
+        const columns = Object.keys(types).map((name) => {
+            const replacement = outputs.get(name.toLowerCase());
+            return replacement === undefined
+                ? `original.${q(name)}`
+                : `generated.${q(replacement)} AS ${q(name)}`;
+        });
+        const existing = new Set(Object.keys(types).map((name) => name.toLowerCase()));
+        for (const name of outputColumns) {
+            if (!existing.has(name.toLowerCase())) {
+                columns.push(`generated.${q(name)}`);
+            }
+        }
+        await table.sdb.customQuery(`CREATE OR REPLACE TABLE ${q(table.name)} AS SELECT ${columns.join(", ")} FROM ${q(snapshot)} original JOIN ${q(staged.name)} generated ON original.${q(id)} = CAST(generated.${q(id)} AS BIGINT) ORDER BY original.${q(id)}`);
+    }
+    finally {
+        await table.sdb.customQuery(`DROP TABLE IF EXISTS ${q(snapshot)}; DROP TABLE IF EXISTS ${q(staged.name)}; DROP TABLE IF EXISTS ${q(batch.name)};`);
+        retainRegisteredTables(table.sdb, (item) => item !== staged && item !== batch);
+    }
+}

package/esm/methods/addColumn.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"addColumn.d.ts","sourceRoot":"","sources":["../../src/methods/addColumn.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,IAAI,EACA,SAAS,GACT,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,MAAM,GACN,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,WAAW,GACX,0BAA0B,GAC1B,SAAS,GACT,aAAa,MAAM,IAAI,GACvB,aAAa,MAAM,IAAI,EAC3B,UAAU,EAAE,MAAM,QAuBnB"}
+{"version":3,"file":"addColumn.d.ts","sourceRoot":"","sources":["../../src/methods/addColumn.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,IAAI,EACA,SAAS,GACT,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,MAAM,GACN,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,WAAW,GACX,0BAA0B,GAC1B,SAAS,GACT,MAAM,GACN,MAAM,GACN,SAAS,MAAM,GAAG,GAClB,SAAS,MAAM,GAAG,GAClB,aAAa,MAAM,IAAI,GACvB,aAAa,MAAM,IAAI,EAC3B,UAAU,EAAE,MAAM,QAuBnB"}

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

@@ -1 +1 @@
-{"version":3,"file":"bm25.d.ts","sourceRoot":"","sources":["../../src/methods/bm25.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACP,OAAO,CAAC,EACJ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,OAAO,GACP,SAAS,GACT,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,OAAO,GACP,WAAW,GACX,YAAY,GACZ,OAAO,GACP,SAAS,GACT,YAAY,GACZ,QAAQ,GACR,WAAW,GACX,QAAQ,GACR,YAAY,GACZ,UAAU,GACV,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,GACT,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,GACL,WAAW,CA4Bb"}
+{"version":3,"file":"bm25.d.ts","sourceRoot":"","sources":["../../src/methods/bm25.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACP,OAAO,CAAC,EACJ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,OAAO,GACP,SAAS,GACT,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,OAAO,GACP,WAAW,GACX,YAAY,GACZ,OAAO,GACP,SAAS,GACT,YAAY,GACZ,QAAQ,GACR,WAAW,GACX,QAAQ,GACR,YAAY,GACZ,UAAU,GACV,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,GACT,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,GACL,WAAW,CA4Bb"}

package/esm/methods/bm25.js

@@ -1,5 +1,4 @@
 import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import camelCase from "../helpers/camelCase.js";
 import queryDB from "../helpers/queryDB.js";
 import mergeOptions from "../helpers/mergeOptions.js";
 import queueOp from "../helpers/queueOp.js";
@@ -39,7 +38,7 @@ async function executeBm25(simpleTable, outputTable, text, idColumn, textColumn,
     const selectClause = typeof options.scoreColumn === "string"
         ? `* EXCLUDE(score), score AS ${quoteIdentifier(options.scoreColumn)}`
         : `* EXCLUDE(score)`;
-    await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable.name)} AS SELECT ${selectClause} FROM (SELECT *, ${quoteIdentifier(`fts_main_${camelCase(simpleTable.name)}`)}.match_bm25(${quoteIdentifier(idColumn)}, ?${typeof options.k === "number" ? `, k := ${options.k}` : ""}${typeof options.b === "number" ? `, b := ${options.b}` : ""}${options.conjunctive === true ? `, conjunctive := 1` : ""}) AS score FROM ${quoteIdentifier(simpleTable.name)}) sq WHERE score NOT NULL${minScoreCondition} ORDER BY score DESC LIMIT ${count};`, mergeOptions(simpleTable, {
+    await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable.name)} AS SELECT ${selectClause} FROM (SELECT *, ${quoteIdentifier(`fts_main_${simpleTable.name}`)}.match_bm25(${quoteIdentifier(idColumn)}, ?${typeof options.k === "number" ? `, k := ${options.k}` : ""}${typeof options.b === "number" ? `, b := ${options.b}` : ""}${options.conjunctive === true ? `, conjunctive := 1` : ""}) AS score FROM ${quoteIdentifier(simpleTable.name)}) sq WHERE score NOT NULL${minScoreCondition} ORDER BY score DESC LIMIT ${count};`, mergeOptions(simpleTable, {
         table: simpleTable.name,
         method: "bm25",
         parameters: {

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

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/methods/cache.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AA2DvD,wBAA8B,KAAK,CAAC,KAAK,SAAS,WAAW,EAC3D,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC/C,OAAO,GAAE;IACP,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,iBAwLP"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/methods/cache.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AA4DvD,wBAA8B,KAAK,CAAC,KAAK,SAAS,WAAW,EAC3D,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC/C,OAAO,GAAE;IACP,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,iBA4LP"}

package/esm/methods/cache.js

@@ -6,11 +6,12 @@ import { cacheEntryExpired, cacheLoadMessage, cacheTtlMessage, } from "../helper
 import serializeCacheInputs, { getCacheInputLabel, } from "../helpers/serializeCacheInputs.js";
 import { createTableGenerationId, peekTableGeneration, restoreTableGeneration, } from "../helpers/tableGeneration.js";
 import { loadCacheDatabase, writeCacheDatabase, } from "../helpers/cacheDatabase.js";
-import { cacheTableDependenciesMatch, captureCacheTableDependencies, changedCacheTableDependenciesMessage, recordCacheTableAccess, unchangedCacheTableDependenciesMessage, } from "../helpers/cacheTableDependencies.js";
+import { assertCacheTableMutation, cacheTableDependenciesMatch, captureCacheTableDependencies, changedCacheTableDependenciesMessage, recordCacheTableAccess, unchangedCacheTableDependenciesMessage, } from "../helpers/cacheTableDependencies.js";
 const CACHE_FORMAT_VERSION = "duckdb-v4";
 export default async function cache(table, compute, options = {}) {
     // If cache() is itself called from another cache computation, the outer
     // computation depends on the table produced here.
+    assertCacheTableMutation(table);
     recordCacheTableAccess(table);
     options.verbose &&
         console.log(`\ncache() for ${table.name}`);
@@ -31,12 +32,13 @@ export default async function cache(table, compute, options = {}) {
     const inputs = options.inputs?.filter((input) => input !== table) ?? [];
     const hasInputs = inputs.length > 0;
     const serializedInputs = hasInputs ? serializeCacheInputs(inputs) : null;
-    const codeHash = createHash(functionBody);
+    const codeHash = createHash(JSON.stringify([table.sdb.expressionSyntax, functionBody]));
     const inputHashes = hasInputs
         ? inputs.map((input) => createHash(serializeCacheInputs([input])))
         : [];
     const hash = createHash(JSON.stringify([
         CACHE_FORMAT_VERSION,
+        table.sdb.expressionSyntax,
         table.name,
         entryGeneration,
         functionBody,
@@ -119,10 +121,6 @@ async function runAndWrite(table, compute, cacheSources, cacheSourcesPath, cache
     const start = Date.now();
     const tableDependencies = await 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 flushAllTables(table.sdb);
     });
     const end = Date.now();
     const duration = end - start;

package/esm/methods/convert.d.ts

@@ -1,12 +1,12 @@
 import type SimpleTable from "../class/SimpleTable.js";
 import type { TableSchema } from "../helpers/pendingOps.js";
 export default function convert(simpleTable: SimpleTable, types: {
-    [key: string]: "integer" | "float" | "number" | "string" | "date" | "time" | "datetime" | "datetimeTz" | "bigint" | "double" | "varchar" | "timestamp" | "timestamp with time zone" | "boolean";
+    [key: string]: "integer" | "float" | "number" | "string" | "date" | "time" | "datetime" | "datetimeTz" | "bigint" | "double" | "varchar" | "timestamp" | "timestamp with time zone" | "boolean" | "json" | "JSON" | `float[${number}]` | `FLOAT[${number}]` | `geometry('${string}')` | `GEOMETRY('${string}')`;
 }, options?: {
     strict?: boolean;
     datetimeFormat?: string;
 }): void;
-export declare function convertSelect(input: string, columns: string[], columnsTypes: ("integer" | "float" | "number" | "string" | "date" | "time" | "datetime" | "datetimeTz" | "bigint" | "double" | "varchar" | "timestamp" | "timestamp with time zone" | "boolean")[], allColumns: string[], allTypes: TableSchema, options: {
+export declare function convertSelect(input: string, columns: string[], columnsTypes: ("integer" | "float" | "number" | "string" | "date" | "time" | "datetime" | "datetimeTz" | "bigint" | "double" | "varchar" | "timestamp" | "timestamp with time zone" | "boolean" | "json" | "JSON" | `float[${number}]` | `FLOAT[${number}]` | `geometry('${string}')` | `GEOMETRY('${string}')`)[], allColumns: string[], allTypes: TableSchema, options: {
     datetimeFormat?: string;
     strict?: boolean;
 }): string;

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

@@ -1 +1 @@
-{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../src/methods/convert.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE5D,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE;IACL,CAAC,GAAG,EAAE,MAAM,GACR,SAAS,GACT,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,MAAM,GACN,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,WAAW,GACX,0BAA0B,GAC1B,SAAS,CAAC;CACf,EACD,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACpB,QA+CP;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EAAE,EACjB,YAAY,EAAE,CACV,SAAS,GACT,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,MAAM,GACN,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,WAAW,GACX,0BAA0B,GAC1B,SAAS,CACZ,EAAE,EACH,UAAU,EAAE,MAAM,EAAE,EACpB,QAAQ,EAAE,WAAW,EACrB,OAAO,EAAE;IAAE,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,UAgFvD"}
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../src/methods/convert.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE5D,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE;IACL,CAAC,GAAG,EAAE,MAAM,GACR,SAAS,GACT,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,MAAM,GACN,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,WAAW,GACX,0BAA0B,GAC1B,SAAS,GACT,MAAM,GACN,MAAM,GACN,SAAS,MAAM,GAAG,GAClB,SAAS,MAAM,GAAG,GAClB,aAAa,MAAM,IAAI,GACvB,aAAa,MAAM,IAAI,CAAC;CAC7B,EACD,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACpB,QAkDP;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EAAE,EACjB,YAAY,EAAE,CACV,SAAS,GACT,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,MAAM,GACN,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,WAAW,GACX,0BAA0B,GAC1B,SAAS,GACT,MAAM,GACN,MAAM,GACN,SAAS,MAAM,GAAG,GAClB,SAAS,MAAM,GAAG,GAClB,aAAa,MAAM,IAAI,GACvB,aAAa,MAAM,IAAI,CAC1B,EAAE,EACH,UAAU,EAAE,MAAM,EAAE,EACpB,QAAQ,EAAE,WAAW,EACrB,OAAO,EAAE;IAAE,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,UAuFvD"}

package/esm/methods/convert.js

@@ -9,6 +9,7 @@ export default function convert(simpleTable, types, options = {}) {
         method: "convert()",
         parameters: { types, options },
         needsSchema: true,
+        needsSpatial: Object.values(types).some((type) => type.toLowerCase().startsWith("geometry")),
         outputSchema: (allTypes) => ({
             ...allTypes,
             ...Object.fromEntries(Object.entries(types).map(([column, type]) => [
@@ -78,6 +79,10 @@ export function convertSelect(input, columns, columnsTypes, allColumns, allTypes
             else if (msToTimestamp) {
                 query += ` TIMESTAMP '1970-01-01 00:00:00' + to_milliseconds(${quoteIdentifier(column)}) AS ${quoteIdentifier(column)},`;
             }
+            else if (options.strict === false && expectedType.startsWith("GEOMETRY")) {
+                // DuckDB's geometry parser can throw even inside TRY_CAST.
+                query += ` TRY(CAST(${quoteIdentifier(column)} AS ${expectedType})) AS ${quoteIdentifier(column)},`;
+            }
             else if (stringToNumber) {
                 // Thousand separators would make the cast fail.
                 query += ` ${cast}(REPLACE(${quoteIdentifier(column)}, ',', '') AS ${parseType(columnsTypes[indexOf])}) AS ${quoteIdentifier(column)},`;

package/esm/methods/getBottom.d.ts

@@ -2,7 +2,7 @@ import type SimpleTable from "../class/SimpleTable.js";
 export default function getBottom(simpleTable: SimpleTable, count: number, options?: {
     originalOrder?: boolean;
     conditions?: string;
-}): Promise<{
+}, method?: "getBottom()" | "logBottom()"): Promise<{
     [key: string]: unknown;
 }[]>;
 //# sourceMappingURL=getBottom.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getBottom.d.ts","sourceRoot":"","sources":["../../src/methods/getBottom.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,SAAS,CACrC,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACP,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CAChB;;KA6BP"}
+{"version":3,"file":"getBottom.d.ts","sourceRoot":"","sources":["../../src/methods/getBottom.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,SAAS,CACrC,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACP,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CAChB,EACN,MAAM,GAAE,aAAa,GAAG,aAA6B;;KA6BtD"}

package/esm/methods/getBottom.js

@@ -1,14 +1,14 @@
 import quoteIdentifier from "../helpers/quoteIdentifier.js";
 import mergeOptions from "../helpers/mergeOptions.js";
 import queryDB from "../helpers/queryDB.js";
-export default async function getBottom(simpleTable, count, options = {}) {
+export default async function getBottom(simpleTable, count, options = {}, method = "getBottom()") {
     const queryResult = await queryDB(simpleTable, `WITH "numberedRowsForGetBottom" AS (
                 SELECT *, row_number() OVER () as "rowNumberForGetBottom" FROM ${quoteIdentifier(simpleTable.name)}${options.conditions ? ` WHERE ${options.conditions}` : ""}
             )
             SELECT * FROM "numberedRowsForGetBottom" ORDER BY "rowNumberForGetBottom" DESC LIMIT ${count};`, mergeOptions(simpleTable, {
         table: simpleTable.name,
         returnData: true,
-        method: "getBottom()",
+        method,
         parameters: { count, options },
     }));
     if (!queryResult) {

package/esm/methods/getData.d.ts

@@ -3,7 +3,7 @@ export default function getData(simpleTable: SimpleTable, options?: {
     columns?: string | string[];
     conditions?: string;
     limit?: number;
-}): Promise<{
+}, method?: "getData()" | "log()"): Promise<{
     [key: string]: unknown;
 }[]>;
 //# sourceMappingURL=getData.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getData.d.ts","sourceRoot":"","sources":["../../src/methods/getData.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,wBAA8B,OAAO,CACnC,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE;IACP,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CACX;;KAmCP"}
+{"version":3,"file":"getData.d.ts","sourceRoot":"","sources":["../../src/methods/getData.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,wBAA8B,OAAO,CACnC,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE;IACP,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CACX,EACN,MAAM,GAAE,WAAW,GAAG,OAAqB;;KAmC5C"}

package/esm/methods/getData.js

@@ -2,7 +2,7 @@ import mergeOptions from "../helpers/mergeOptions.js";
 import queryDB from "../helpers/queryDB.js";
 import quoteIdentifier from "../helpers/quoteIdentifier.js";
 import quoteQualifiedIdentifier from "../helpers/quoteQualifiedIdentifier.js";
-export default async function getData(simpleTable, options = {}) {
+export default async function getData(simpleTable, options = {}, method = "getData()") {
     if (options.limit !== undefined &&
         (!Number.isInteger(options.limit) || options.limit < 0)) {
         throw new Error("getData() limit must be an integer greater than or equal to 0.");
@@ -17,7 +17,7 @@ export default async function getData(simpleTable, options = {}) {
         : "*"} from ${quoteIdentifier(simpleTable.name)}${options.conditions ? ` WHERE ${options.conditions}` : ""}${options.limit === undefined ? "" : ` LIMIT ${options.limit}`}`, mergeOptions(simpleTable, {
         returnData: true,
         table: simpleTable.name,
-        method: "getData()",
+        method,
         parameters: { options },
     })));
 }

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

@@ -1 +1 @@
-{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../src/methods/join.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAOvD,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,SAAS,EAAE,WAAW,EACtB,UAAU,EAAE,WAAW,EACvB,OAAO,GAAE;IACP,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAC3C,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,GACL,WAAW,CAiBb"}
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../src/methods/join.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAKvD,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,SAAS,EAAE,WAAW,EACtB,UAAU,EAAE,WAAW,EACvB,OAAO,GAAE;IACP,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAC3C,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,GACL,WAAW,CAkBb"}

package/esm/methods/join.js

@@ -1,7 +1,5 @@
 import quoteIdentifier from "../helpers/quoteIdentifier.js";
 import getIdenticalColumns from "../helpers/getIdenticalColumns.js";
-import mergeOptions from "../helpers/mergeOptions.js";
-import queryDB from "../helpers/queryDB.js";
 import queueOp from "../helpers/queueOp.js";
 import assertSameDatabase from "../helpers/assertSameDatabase.js";
 export default function join(leftTable, rightTable, options = {}) {
@@ -13,14 +11,15 @@ export default function join(leftTable, rightTable, options = {}) {
         ? leftTable.sdb.newTable(options.outputTable)
         : leftTable;
     queueOp(outputTable, {
-        kind: "barrier",
+        kind: "source",
+        rawSQL: [quoteIdentifier(leftTable.name), quoteIdentifier(rightTable.name)],
         method: "join()",
         parameters: { rightTable: rightTable.name, options },
-        execute: () => executeJoin(leftTable, rightTable, outputTable, options),
+        buildSelect: () => buildJoinSelect(leftTable, rightTable, options),
     });
     return outputTable;
 }
-async function executeJoin(leftTable, rightTable, outputTable, options) {
+async function buildJoinSelect(leftTable, rightTable, options) {
     const leftTableColumns = await leftTable.getColumns();
     const rightTableColumns = await rightTable.getColumns();
     const identicalColumns = getIdenticalColumns(leftTableColumns, rightTableColumns);
@@ -74,17 +73,10 @@ async function executeJoin(leftTable, rightTable, outputTable, options) {
             .filter((d) => !on.includes(d))
             .map((d) => `${quoteIdentifier(rightTable.name)}.${quoteIdentifier(d)}`),
     ].join(", ");
-    await queryDB(leftTable, joinQuery(leftTable.name, rightTable.name, on, type, outputTable.name, selectList), mergeOptions(leftTable, {
-        table: outputTable.name,
-        method: "join()",
-        parameters: {
-            rightTable: rightTable.name,
-            options,
-        },
-    }));
+    return joinQuery(leftTable.name, rightTable.name, on, type, selectList);
 }
-function joinQuery(leftTable, rightTable, on, join, outputTable, selectList) {
-    let query = `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable)} AS SELECT ${selectList}`;
+function joinQuery(leftTable, rightTable, on, join, selectList) {
+    let query = `SELECT ${selectList}`;
     if (join === "inner") {
         query += ` FROM ${quoteIdentifier(leftTable)} JOIN ${quoteIdentifier(rightTable)}`;
     }
@@ -101,6 +93,6 @@ function joinQuery(leftTable, rightTable, on, join, outputTable, selectList) {
         throw new Error(`Unknown ${join} join.`);
     }
     query += ` ON (${on.map((d) => `${quoteIdentifier(leftTable)}.${quoteIdentifier(d)} = ${quoteIdentifier(rightTable)}.${quoteIdentifier(d)}`)
-        .join(" AND ")});\n`;
+        .join(" AND ")})`;
     return query;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"joinGeo.d.ts","sourceRoot":"","sources":["../../src/methods/joinGeo.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAQvD,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,SAAS,EAAE,WAAW,EACtB,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,gBAAgB,EACjD,UAAU,EAAE,WAAW,EACvB,OAAO,GAAE;IACP,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,KAAK,GAAG,WAAW,GAAG,UAAU,CAAC;IAClD,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,GACL,WAAW,CAmBb"}
+{"version":3,"file":"joinGeo.d.ts","sourceRoot":"","sources":["../../src/methods/joinGeo.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,SAAS,EAAE,WAAW,EACtB,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,gBAAgB,EACjD,UAAU,EAAE,WAAW,EACvB,OAAO,GAAE;IACP,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,KAAK,GAAG,WAAW,GAAG,UAAU,CAAC;IAClD,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,GACL,WAAW,CAqBb"}

package/esm/methods/joinGeo.js

@@ -2,8 +2,6 @@ import quoteIdentifier from "../helpers/quoteIdentifier.js";
 import capitalize from "../helpers/capitalize.js";
 import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
 import getIdenticalColumns from "../helpers/getIdenticalColumns.js";
-import mergeOptions from "../helpers/mergeOptions.js";
-import queryDB from "../helpers/queryDB.js";
 import queueOp from "../helpers/queueOp.js";
 import assertSameDatabase from "../helpers/assertSameDatabase.js";
 export default function joinGeo(leftTable, method, rightTable, options = {}) {
@@ -16,10 +14,12 @@ export default function joinGeo(leftTable, method, rightTable, options = {}) {
         ? leftTable.sdb.newTable(options.outputTable)
         : leftTable;
     queueOp(outputTable, {
-        kind: "barrier",
+        kind: "source",
+        rawSQL: [quoteIdentifier(leftTable.name), quoteIdentifier(rightTable.name)],
+        needsSpatial: true,
         method: "joinGeo()",
         parameters: { method, rightTable: rightTable.name, options },
-        execute: () => executeJoinGeo(leftTable, method, rightTable, outputTable, options),
+        buildSelect: () => buildJoinGeoSelect(leftTable, method, rightTable, options),
     });
     return outputTable;
 }
@@ -43,7 +43,7 @@ function validateJoinGeoOptions(method, options) {
 function formatReceivedValue(value) {
     return JSON.stringify(value) ?? String(value);
 }
-async function executeJoinGeo(leftTable, method, rightTable, outputTable, options) {
+async function buildJoinGeoSelect(leftTable, method, rightTable, options) {
     const leftTypes = await leftTable.getTypes();
     const rightTypes = await rightTable.getTypes();
     const leftColumn = options.leftColumn ??
@@ -83,19 +83,10 @@ async function executeJoinGeo(leftTable, method, rightTable, outputTable, option
         ]),
     ].join(", ");
     const type = options.type ?? "left";
-    await queryDB(leftTable, joinGeoQuery(leftTable.name, leftColumn, method, rightTable.name, rightColumn, type, outputTable.name, selectList, options.distance, options.distanceMethod), mergeOptions(leftTable, {
-        table: outputTable.name,
-        method: "joinGeo()",
-        parameters: {
-            leftTable: leftTable.name,
-            method,
-            rightTable: rightTable.name,
-            options,
-        },
-    }));
+    return joinGeoQuery(leftTable.name, leftColumn, method, rightTable.name, rightColumn, type, selectList, options.distance, options.distanceMethod);
 }
-function joinGeoQuery(leftTable, leftColumn, method, rightTable, rightColumn, join, outputTable, selectList, distance, distanceMethod) {
-    let query = `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable)} AS SELECT ${selectList}`;
+function joinGeoQuery(leftTable, leftColumn, method, rightTable, rightColumn, join, selectList, distance, distanceMethod) {
+    let query = `SELECT ${selectList}`;
     if (join === "inner") {
         query += ` FROM ${quoteIdentifier(leftTable)} JOIN ${quoteIdentifier(rightTable)}`;
     }
@@ -112,11 +103,11 @@ function joinGeoQuery(leftTable, leftColumn, method, rightTable, rightColumn, jo
         throw new Error(`Unknown ${join} join.`);
     }
     if (method === "intersect") {
-        query += ` ON ST_Intersects(${quoteIdentifier(leftTable)}.${quoteIdentifier(leftColumn)}, ${quoteIdentifier(rightTable)}.${quoteIdentifier(rightColumn)});`;
+        query += ` ON ST_Intersects(${quoteIdentifier(leftTable)}.${quoteIdentifier(leftColumn)}, ${quoteIdentifier(rightTable)}.${quoteIdentifier(rightColumn)})`;
     }
     else if (method === "inside") {
         // Order is important
-        query += ` ON ST_Covers(${quoteIdentifier(rightTable)}.${quoteIdentifier(rightColumn)}, ${quoteIdentifier(leftTable)}.${quoteIdentifier(leftColumn)});`;
+        query += ` ON ST_Covers(${quoteIdentifier(rightTable)}.${quoteIdentifier(rightColumn)}, ${quoteIdentifier(leftTable)}.${quoteIdentifier(leftColumn)})`;
     }
     else if (method === "withinDistance") {
         if (typeof distance === "number") {

package/esm/methods/loadArray.d.ts

@@ -13,7 +13,7 @@ export declare function prepareArray(rows: {
     [key: string]: unknown;
 }[], columnTypes?: {
     [key: string]: string;
-}): PreparedArray;
+}, requireExplicitNestedTypes?: boolean): PreparedArray;
 export declare function executePreparedArray(simpleTable: SimpleTable, prepared: PreparedArray): Promise<void>;
 export {};
 //# sourceMappingURL=loadArray.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"loadArray.d.ts","sourceRoot":"","sources":["../../src/methods/loadArray.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAKvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,EAClC,OAAO,GAAE,WAAW,CAAC,UAAU,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAM,QAiBnE;AAED,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,WAAW,EAAE,WAAW,EAAE,EAAE,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,YAAY,CAC1B,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,EAClC,WAAW,GAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAO,GAC1C,aAAa,CA2Ff;AAED,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,aAAa,iBA+BxB"}
+{"version":3,"file":"loadArray.d.ts","sourceRoot":"","sources":["../../src/methods/loadArray.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAK1B,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAKvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,EAClC,OAAO,GAAE,WAAW,CAAC,UAAU,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAM,QAiBnE;AAED,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,WAAW,EAAE,WAAW,EAAE,EAAE,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,YAAY,CAC1B,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,EAClC,WAAW,GAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAO,EAC3C,0BAA0B,UAAQ,GACjC,aAAa,CAsHf;AAED,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,aAAa,iBA4ExB"}

package/esm/methods/loadArray.js

@@ -1,4 +1,7 @@
 import { arrayValue, DuckDBDataChunk, DuckDBDateValue, DuckDBTimestampTZValue, DuckDBTimestampValue, DuckDBTimeValue, } from "@duckdb/node-api";
+import prepareGeometry from "../helpers/prepareGeometry.js";
+import prepareJSON from "../helpers/prepareJSON.js";
+import geometryFromJSON from "../helpers/geometryFromJSON.js";
 import queueOp from "../helpers/queueOp.js";
 import parseType from "../helpers/parseTypes.js";
 import parseDuckDBType from "../helpers/parseDuckDBType.js";
@@ -8,7 +11,7 @@ export default function loadArray(simpleTable, rows, options = {}) {
     if (rows.length === 0) {
         throw new Error("The array is empty. loadArray needs at least one object to infer the column types.");
     }
-    const prepared = prepareArray(rows, options.columnTypes);
+    const prepared = prepareArray(rows, options.columnTypes, true);
     queueOp(simpleTable, {
         kind: "barrier",
         method: "loadArray()",
@@ -16,17 +19,26 @@ export default function loadArray(simpleTable, rows, options = {}) {
         execute: () => executePreparedArray(simpleTable, prepared),
     });
 }
-export function prepareArray(rows, columnTypes = {}) {
+export function prepareArray(rows, columnTypes = {}, requireExplicitNestedTypes = false) {
     const keys = Object.keys(rows[0]);
     const overrides = new Map();
     for (const [key, type] of Object.entries(columnTypes)) {
         if (!keys.includes(key)) {
             throw new Error(`Unknown column ${JSON.stringify(key)} in loadArray columnTypes.`);
         }
+        if (type.toUpperCase() === "JSON") {
+            overrides.set(key, "JSON");
+            continue;
+        }
+        if (/^geometry/i.test(type)) {
+            if (!/^geometry\('EPSG:4326'\)$/i.test(type)) {
+                throw new Error(`Unsupported type ${JSON.stringify(type)} for column ${JSON.stringify(key)}. GeoJSON ingestion requires GEOMETRY('EPSG:4326'); reproject input to WGS84 first.`);
+            }
+            overrides.set(key, "GEOMETRY('EPSG:4326')");
+            continue;
+        }
         try {
-            const normalized = /^FLOAT\[[1-9]\d*\]$/i.test(type)
-                ? type.toUpperCase()
-                : parseType(type);
+            const normalized = parseType(type);
             parseDuckDBType(normalized);
             overrides.set(key, normalized);
         }
@@ -48,6 +60,14 @@ export function prepareArray(rows, columnTypes = {}) {
             }
             continue;
         }
+        if (requireExplicitNestedTypes) {
+            for (let j = 0; j < rows.length; j++) {
+                const cell = rows[j][key];
+                if (cell !== null && typeof cell === "object" && !(cell instanceof Date)) {
+                    throw new Error(`Column ${JSON.stringify(key)}, row ${j + 1}: array and object cells require an explicit columnTypes entry. Use JSON for nested data, FLOAT[n] for fixed-size vectors, or GEOMETRY('EPSG:4326') for GeoJSON geometries.`);
+                }
+            }
+        }
         const value = firstNonNullValue[i];
         const type = typeof value;
         if (type === "symbol" || type === "function") {
@@ -104,24 +124,59 @@ export async function executePreparedArray(simpleTable, prepared) {
         simpleTable.connection = simpleTable.sdb.connection;
     }
     const { keys, types, columnsData, rowCount } = prepared;
-    await simpleTable.sdb.customQuery(`CREATE OR REPLACE TABLE ${quoteIdentifier(simpleTable.name)}(${keys.map((key, i) => `${quoteIdentifier(key)} ${types[i]}`).join(", ")})`);
-    const appender = await simpleTable.connection
-        .createAppender(simpleTable.name);
-    const duckDBTypes = types.map((d) => parseDuckDBType(d));
-    // The maximum capacity of a DuckDB data chunk is 2048 rows.
-    const chunkSize = 2000;
-    for (let start = 0; start < rowCount; start += chunkSize) {
-        const end = Math.min(start + chunkSize, rowCount);
-        const dataChunk = DuckDBDataChunk.create(duckDBTypes, end - start);
-        for (let i = 0; i < keys.length; i++) {
-            dataChunk.setColumnValues(i, columnsData[i].slice(start, end));
-        }
-        appender.appendDataChunk(dataChunk);
+    const hasGeometry = types.includes("GEOMETRY('EPSG:4326')");
+    const needsConversion = hasGeometry || types.includes("JSON");
+    const staged = needsConversion
+        ? `__sda_array_${crypto.randomUUID().replaceAll("-", "")}`
+        : simpleTable.name;
+    const storageTypes = types.map((type) => type.startsWith("GEOMETRY") || type === "JSON" ? "VARCHAR" : type);
+    if (hasGeometry && !simpleTable.sdb.spatialLoaded) {
+        await simpleTable.sdb.customQuery("INSTALL spatial; LOAD spatial; SET geometry_always_xy = true;");
+        simpleTable.sdb.spatialLoaded = true;
+    }
+    try {
+        await simpleTable.sdb.customQuery(`CREATE ${needsConversion ? "TEMP" : "OR REPLACE"} TABLE ${quoteIdentifier(staged)}(${keys.map((key, i) => `${quoteIdentifier(key)} ${storageTypes[i]}`).join(", ")})`);
+        const appender = await simpleTable.connection
+            .createAppender(staged);
+        try {
+            const duckDBTypes = storageTypes.map((d) => parseDuckDBType(d));
+            // The maximum capacity of a DuckDB data chunk is 2048 rows.
+            const chunkSize = 2000;
+            for (let start = 0; start < rowCount; start += chunkSize) {
+                const end = Math.min(start + chunkSize, rowCount);
+                const dataChunk = DuckDBDataChunk.create(duckDBTypes, end - start);
+                for (let i = 0; i < keys.length; i++) {
+                    dataChunk.setColumnValues(i, columnsData[i].slice(start, end));
+                }
+                appender.appendDataChunk(dataChunk);
+            }
+            appender.flushSync();
+        }
+        finally {
+            appender.closeSync();
+        }
+        if (!needsConversion)
+            return;
+        // CTAS is atomic: conversion must finish before the destination is replaced.
+        await simpleTable.sdb.customQuery(`CREATE OR REPLACE TABLE ${quoteIdentifier(simpleTable.name)} AS SELECT ${keys.map((key, i) => types[i].startsWith("GEOMETRY")
+            ? `${geometryFromJSON(quoteIdentifier(key))} AS ${quoteIdentifier(key)}`
+            : types[i] === "JSON"
+                ? `${quoteIdentifier(key)}::JSON AS ${quoteIdentifier(key)}`
+                : quoteIdentifier(key)).join(", ")} FROM ${quoteIdentifier(staged)}`);
+    }
+    finally {
+        if (needsConversion) {
+            await simpleTable.sdb.customQuery(`DROP TABLE IF EXISTS ${quoteIdentifier(staged)}`);
+        }
     }
-    appender.flushSync();
 }
 /** Validates and snapshots a value for an explicitly declared destination type. */
 function prepareTypedValue(value, type, column, row) {
+    if (type === "JSON")
+        return prepareJSON(value, column, row);
+    if (type === "GEOMETRY('EPSG:4326')") {
+        return prepareGeometry(value, column, row);
+    }
     if (value === null || value === undefined || Number.isNaN(value))
         return null;
     let compatible = false;