@nshiab/simple-data-analysis 5.21.0 → 6.0.0

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadArray.js

@@ -0,0 +1,98 @@
+import { arrayValue, DuckDBDataChunk, DuckDBTimestampValue, } from "@duckdb/node-api";
+import queueOp from "../helpers/queueOp.js";
+import parseType from "../helpers/parseTypes.js";
+import parseDuckDBType from "../helpers/parseDuckDBType.js";
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+export default function loadArray(simpleTable, rows) {
+    // This validation doesn't need the database, so it stays at call time.
+    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);
+    queueOp(simpleTable, {
+        kind: "barrier",
+        method: "loadArray()",
+        parameters: { rows: `${rows.length} rows` },
+        execute: () => executePreparedArray(simpleTable, prepared),
+    });
+}
+export function prepareArray(rows) {
+    const keys = Object.keys(rows[0]);
+    const firstNonNullValue = keys.map((key) => rows.find((obj) => obj[key] !== null && obj[key] !== undefined)?.[key]);
+    const types = [];
+    const columnsData = keys.map(() => new Array(rows.length));
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const columnData = columnsData[i];
+        const value = firstNonNullValue[i];
+        const type = typeof value;
+        if (type === "symbol" || type === "function") {
+            throw new Error(`Type ${type} not supported for ${key}. Value: ${value}`);
+        }
+        else if (type === "undefined") {
+            types[i] = "VARCHAR";
+            for (let j = 0; j < rows.length; j++) {
+                columnData[j] = null;
+            }
+        }
+        else if (type === "object") {
+            if (value instanceof Date) {
+                types[i] = "TIMESTAMP";
+                for (let j = 0; j < rows.length; j++) {
+                    const d = rows[j][key];
+                    if (d === null || d === undefined || Number.isNaN(d)) {
+                        columnData[j] = null;
+                    }
+                    else {
+                        const date = d;
+                        columnData[j] = new DuckDBTimestampValue(BigInt(date.getTime() * 1000));
+                    }
+                }
+            }
+            else if (Array.isArray(value)) {
+                types[i] = `FLOAT[${value.length}]`;
+                for (let j = 0; j < rows.length; j++) {
+                    const d = rows[j][key];
+                    columnData[j] = d === null || d === undefined
+                        ? null
+                        : arrayValue([...d]);
+                }
+            }
+            else {
+                throw new Error(`Type object not supported for ${key}. Value: ${value}`);
+            }
+        }
+        else {
+            types[i] = parseType(type);
+            for (let j = 0; j < rows.length; j++) {
+                const d = rows[j][key];
+                columnData[j] = d === null || d === undefined || Number.isNaN(d)
+                    ? null
+                    : d;
+            }
+        }
+    }
+    return { keys, types, columnsData, rowCount: rows.length };
+}
+export async function executePreparedArray(simpleTable, prepared) {
+    if (simpleTable.connection === undefined) {
+        await simpleTable.sdb.start();
+        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);
+    }
+    appender.flushSync();
+}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadDB.d.ts

@@ -0,0 +1,3 @@
+import type SimpleDB from "../class/SimpleDB.js";
+export default function loadDB(sdb: SimpleDB, file: string): Promise<void>;
+//# sourceMappingURL=loadDB.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadDB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadDB.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadDB.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AAYjD,wBAA8B,MAAM,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,iBA0E/D"}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadDB.js

@@ -0,0 +1,70 @@
+import queryDbFile from "../helpers/queryDbFile.js";
+import { existsSync } from "node:fs";
+import cleanPath from "../helpers/cleanPath.js";
+import getDbFileType from "../helpers/getDbFileType.js";
+import getCurrentDatabase from "../helpers/getCurrentDatabase.js";
+import getDbIndexes from "../helpers/getDbIndexes.js";
+import parseValue from "../helpers/parseValue.js";
+import prepareDbExtensions from "../helpers/prepareDbExtensions.js";
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import readDbMetadata from "../helpers/readDbMetadata.js";
+import setDbProps from "../helpers/setDbProps.js";
+import writeDbMetadata from "../helpers/writeDbMetadata.js";
+export default async function loadDB(sdb, file) {
+    const type = getDbFileType(file);
+    if (!existsSync(file))
+        throw new Error(`The file ${file} does not exist.`);
+    if (sdb.readOnly) {
+        throw new Error("loadDB() cannot import into a read-only database.");
+    }
+    const destination = await getCurrentDatabase(sdb);
+    const target = quoteIdentifier(destination);
+    const name = `__sda_import_${crypto.randomUUID().replaceAll("-", "")}`;
+    const source = quoteIdentifier(name);
+    if (type === "sqlite")
+        await queryDbFile(sdb, "INSTALL sqlite; LOAD sqlite;");
+    await queryDbFile(sdb, `ATTACH '${cleanPath(file)}' AS ${source} (TYPE ${type}, READ_ONLY);`);
+    let inTransaction = false;
+    try {
+        const indexes = type === "duckdb" ? await readDbMetadata(sdb, name) : {};
+        await readDbMetadata(sdb, destination);
+        await prepareDbExtensions(sdb, name, indexes);
+        const conflicts = await queryDbFile(sdb, `SELECT incoming.table_schema, incoming.table_name
+       FROM information_schema.tables incoming
+       JOIN information_schema.tables existing
+         ON lower(incoming.table_schema) = lower(existing.table_schema)
+         AND lower(incoming.table_name) = lower(existing.table_name)
+       WHERE incoming.table_catalog = ${parseValue(name)}
+         AND existing.table_catalog = ${parseValue(destination)}
+         AND incoming.table_schema <> '__sda';`, { returnData: true });
+        // Also protect registered table handles that have no physical table yet.
+        const incoming = await queryDbFile(sdb, `SELECT table_name FROM information_schema.tables
+       WHERE table_catalog = ${parseValue(name)} AND table_schema = 'main';`, { returnData: true });
+        const registered = new Set(sdb.getTables().map((table) => table.name.toLowerCase()));
+        const names = new Set([
+            ...conflicts.map((row) => `${row.table_schema}.${row.table_name}`),
+            ...incoming.filter((row) => registered.has(String(row.table_name).toLowerCase()))
+                .map((row) => `main.${row.table_name}`),
+        ]);
+        if (names.size > 0) {
+            throw new Error(`loadDB() cannot import existing tables: ${[...names].join(", ")}.`);
+        }
+        const mergedIndexes = { ...getDbIndexes(sdb), ...indexes };
+        await queryDbFile(sdb, "BEGIN TRANSACTION;");
+        inTransaction = true;
+        await queryDbFile(sdb, `DROP TABLE IF EXISTS ${target}.__sda.metadata;
+       COPY FROM DATABASE ${source} TO ${target};`);
+        await writeDbMetadata(sdb, destination, mergedIndexes);
+        await queryDbFile(sdb, "COMMIT;");
+        inTransaction = false;
+        await setDbProps(sdb, indexes);
+    }
+    catch (error) {
+        if (inTransaction)
+            await queryDbFile(sdb, "ROLLBACK;");
+        throw error;
+    }
+    finally {
+        await queryDbFile(sdb, `DETACH ${source};`);
+    }
+}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadData.d.ts

@@ -0,0 +1,52 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function loadData(simpleTable: SimpleTable, files: string | string[], options?: {
+    fileType?: "csv" | "dsv" | "json" | "parquet" | "excel";
+    autoDetect?: boolean;
+    conditions?: string;
+    limit?: number;
+    includeFilename?: boolean;
+    unifyColumns?: boolean;
+    columnTypes?: {
+        [key: string]: string;
+    };
+    columns?: string[];
+    header?: boolean;
+    allText?: boolean;
+    delim?: string;
+    skip?: number;
+    nullPadding?: boolean;
+    ignoreErrors?: boolean;
+    compression?: "none" | "gzip" | "zstd";
+    encoding?: string;
+    strict?: boolean;
+    jsonFormat?: "unstructured" | "newlineDelimited" | "array";
+    records?: boolean;
+    sheet?: string;
+}): void;
+type LoadDataOptions = {
+    fileType?: "csv" | "dsv" | "json" | "parquet" | "excel";
+    autoDetect?: boolean;
+    conditions?: string;
+    limit?: number;
+    includeFilename?: boolean;
+    unifyColumns?: boolean;
+    columnTypes?: {
+        [key: string]: string;
+    };
+    columns?: string[];
+    header?: boolean;
+    allText?: boolean;
+    delim?: string;
+    skip?: number;
+    nullPadding?: boolean;
+    ignoreErrors?: boolean;
+    compression?: "none" | "gzip" | "zstd";
+    encoding?: string;
+    strict?: boolean;
+    jsonFormat?: "unstructured" | "newlineDelimited" | "array";
+    records?: boolean;
+    sheet?: string;
+};
+export declare function loadDataQuery(table: string, files: string[], options?: LoadDataOptions): string;
+export {};
+//# sourceMappingURL=loadData.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadData.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadData.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EACxB,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;IACxD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAExC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB,UAAU,CAAC,EAAE,cAAc,GAAG,kBAAkB,GAAG,OAAO,CAAC;IAC3D,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,KAAK,CAAC,EAAE,MAAM,CAAC;CACX,QAgBP;AAED,KAAK,eAAe,GAAG;IACrB,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;IACxD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACxC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,cAAc,GAAG,kBAAkB,GAAG,OAAO,CAAC;IAC3D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAsCF,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,GAAE,eAAoB,UAK9B"}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadData.js

@@ -0,0 +1,148 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import parseValue from "../helpers/parseValue.js";
+import queueOp from "../helpers/queueOp.js";
+import getExtension from "../helpers/getExtension.js";
+import stringToArray from "../helpers/stringToArray.js";
+export default function loadData(simpleTable, files, options = {}) {
+    files = Array.isArray(files) ? [...files] : files;
+    options = structuredClone(options);
+    // Building the SELECT doesn't need the database, so invalid arguments
+    // (like the columns option with an Excel file) throw at call time.
+    const select = loadDataSelect(stringToArray(files), options);
+    queueOp(simpleTable, {
+        kind: "source",
+        method: "loadData()",
+        parameters: { files, options },
+        rawSQL: options.conditions === undefined ? undefined : [options.conditions],
+        schema: knownSourceSchema(stringToArray(files), options),
+        buildSelect: () => select,
+    });
+}
+function knownSourceSchema(files, options) {
+    if (options.columns === undefined || options.columns.length === 0) {
+        return undefined;
+    }
+    const extension = getExtension(files[0]);
+    const textSource = options.fileType === "csv" ||
+        options.fileType === "dsv" ||
+        options.fileType === "excel" ||
+        extension === "csv" ||
+        extension === "xlsx" ||
+        typeof options.delim === "string";
+    if (!textSource)
+        return undefined;
+    if (options.allText === true) {
+        return Object.fromEntries(options.columns.map((column) => [column, "VARCHAR"]));
+    }
+    if (options.columnTypes !== undefined &&
+        options.columns.every((column) => options.columnTypes?.[column] !== undefined)) {
+        return Object.fromEntries(options.columns.map((column) => [
+            column,
+            options.columnTypes[column].toUpperCase(),
+        ]));
+    }
+    return undefined;
+}
+export function loadDataQuery(table, files, options = {}) {
+    return `CREATE OR REPLACE TABLE ${quoteIdentifier(table)} AS ${loadDataSelect(files, options)};`;
+}
+function loadDataSelect(files, options = {}) {
+    const fileExtension = getExtension(files[0]);
+    if (options.fileType !== undefined &&
+        !["csv", "dsv", "json", "parquet", "excel"].includes(options.fileType)) {
+        throw unsupportedFileTypeError(files[0], options.fileType, fileExtension);
+    }
+    const filesAsString = "[" +
+        files.map((file) => parseValue(file)).join(", ") +
+        "]";
+    // Column selection: throw for Excel, build SELECT list for others
+    const isExcel = options.fileType === "excel" || fileExtension === "xlsx";
+    if (options.columns && options.columns.length > 0 && isExcel) {
+        throw new Error("The 'columns' option is not supported for Excel files.");
+    }
+    const selectColumns = options.columns && options.columns.length > 0
+        ? options.columns.map((c) => `${quoteIdentifier(c)}`).join(", ")
+        : "*";
+    // General options, except for parquet
+    const autoDetect = typeof options.autoDetect === "boolean"
+        ? `, auto_detect=${String(options.autoDetect).toUpperCase()}`
+        : ", auto_detect=TRUE";
+    const columnTypes = options.columnTypes
+        ? `${Object.entries(options.columnTypes).map(([column, type]) => `${parseValue(column)}: ${parseValue(type)}`).join(", ")}`
+        : null;
+    const includeFilename = typeof options.includeFilename === "boolean"
+        ? `, filename=${String(options.includeFilename).toUpperCase()}`
+        : "";
+    const unifyColumns = typeof options.unifyColumns === "boolean"
+        ? `, union_by_name=${String(options.unifyColumns).toUpperCase()}`
+        : "";
+    const generalOptions = `${autoDetect}${includeFilename}${unifyColumns}`;
+    const conditions = options.conditions ? ` WHERE ${options.conditions}` : "";
+    const limit = typeof options.limit === "number"
+        ? ` LIMIT ${options.limit}`
+        : "";
+    if (options.fileType === "csv" ||
+        fileExtension === "csv" ||
+        options.fileType === "dsv" ||
+        typeof options.delim === "string") {
+        const header = typeof options.header === "boolean"
+            ? `, header=${String(options.header).toUpperCase()}`
+            : ", header=TRUE";
+        const allText = typeof options.allText === "boolean"
+            ? `, all_varchar=${String(options.allText).toUpperCase()}`
+            : "";
+        const delim = options.delim ? `, delim=${parseValue(options.delim)}` : "";
+        const skip = options.skip ? `, skip=${options.skip}` : "";
+        const ignoreErrors = options.ignoreErrors
+            ? `, ignore_errors	=${options.ignoreErrors}`
+            : "";
+        const nullPadding = options.nullPadding
+            ? `, null_padding=${options.nullPadding}`
+            : "";
+        const compression = options.compression
+            ? `, compression=${parseValue(options.compression)}`
+            : "";
+        const encoding = options.encoding
+            ? `, encoding=${parseValue(options.encoding)}`
+            : "";
+        const strict = options.strict === false ? `, strict_mode=FALSE` : "";
+        const types = columnTypes === null ? "" : `, types={${columnTypes}}`;
+        return `SELECT ${selectColumns} FROM read_csv_auto(${filesAsString}${generalOptions}${types}${header}${allText}${delim}${skip}${compression}${encoding}${strict}${nullPadding}${ignoreErrors})${conditions}${limit}`;
+    }
+    else if (options.fileType === "json" || fileExtension === "json") {
+        // DuckDB expects "newline_delimited" (snake_case), unlike the other two
+        // format values, which already match the public camelCase option.
+        const jsonFormat = options.jsonFormat
+            ? `, format=${parseValue(options.jsonFormat === "newlineDelimited"
+                ? "newline_delimited"
+                : options.jsonFormat)}`
+            : "";
+        const records = typeof options.records === "boolean"
+            ? `, records=${String(options.records).toUpperCase()}`
+            : "";
+        const columns = columnTypes === null ? "" : `, columns={${columnTypes}}`;
+        return `SELECT ${selectColumns} FROM read_json_auto(${filesAsString}${generalOptions}${columns}${jsonFormat}${records})${conditions}${limit}`;
+    }
+    else if (options.fileType === "parquet" || fileExtension === "parquet") {
+        return `SELECT ${selectColumns} FROM read_parquet(${filesAsString}${includeFilename}${unifyColumns})${conditions}${limit}`;
+    }
+    else if (options.fileType === "excel" || fileExtension === "xlsx") {
+        if (files.length > 1) {
+            throw new Error("For excel files or files with extension .xlsx, you can pass only one file at the time.");
+        }
+        const header = typeof options.header === "boolean"
+            ? `, header=${String(options.header).toUpperCase()}`
+            : ", header=TRUE";
+        const allText = typeof options.allText === "boolean"
+            ? `, all_varchar=${String(options.allText).toUpperCase()}`
+            : "";
+        return `SELECT ${selectColumns} FROM read_xlsx(${parseValue(files[0])}${options.sheet ? `, sheet=${parseValue(options.sheet)}` : ""}${header}${allText})${conditions}${limit}`;
+    }
+    else {
+        throw unsupportedFileTypeError(files[0], options.fileType, fileExtension);
+    }
+}
+function unsupportedFileTypeError(file, fileType, fileExtension) {
+    const receivedFileType = JSON.stringify(fileType) ?? String(fileType);
+    return new Error(`loadData() could not determine a supported file type for ${JSON.stringify(file)}. options.fileType: ${receivedFileType}. Detected extension: ${JSON.stringify(`.${fileExtension}`)}. Supported file types: "csv", "dsv", "json", "parquet", and "excel" (for .xlsx files).`);
+}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadGeoData.d.ts

@@ -0,0 +1,9 @@
+import type SimpleTable from "../class/SimpleTable.js";
+type LoadGeoDataOptions = {
+    toEPSG4326?: boolean;
+    columns?: string[];
+    conditions?: string;
+};
+export default function loadGeoData(simpleTable: SimpleTable, file: string, options?: LoadGeoDataOptions): void;
+export {};
+//# sourceMappingURL=loadGeoData.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadGeoData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadGeoData.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadGeoData.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAWvD,KAAK,kBAAkB,GAAG;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,kBAAuB,QAYjC"}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadGeoData.js

@@ -0,0 +1,104 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import getExtension from "../helpers/getExtension.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import parseValue from "../helpers/parseValue.js";
+import queryDB from "../helpers/queryDB.js";
+import queueOp from "../helpers/queueOp.js";
+import removeColumnsNow from "../helpers/removeColumnsNow.js";
+import { rmSync } from "node:fs";
+import SDAError from "../class/SDAError.js";
+import loadOsmFile from "../helpers/loadOsmFile.js";
+import { recordCacheTableReferences } from "../helpers/cacheTableDependencies.js";
+import { downloadOsmToTemporaryFile, getOsmFileSuffix, isRemoteOsmUrl, } from "../helpers/osmFiles.js";
+export default function loadGeoData(simpleTable, file, options = {}) {
+    options = structuredClone(options);
+    if (options.conditions !== undefined) {
+        recordCacheTableReferences(simpleTable, [options.conditions]);
+    }
+    queueOp(simpleTable, {
+        kind: "barrier",
+        method: "loadGeoData()",
+        parameters: { file, options },
+        execute: () => executeLoadGeoData(simpleTable, file, options),
+    });
+}
+async function executeLoadGeoData(simpleTable, file, options) {
+    const osmSuffix = getOsmFileSuffix(file);
+    if (osmSuffix !== null) {
+        let temporaryFile;
+        try {
+            const localFile = isRemoteOsmUrl(file)
+                ? temporaryFile = await downloadOsmToTemporaryFile(file, {
+                    suffix: osmSuffix,
+                    request: { headers: { "accept-encoding": "gzip" } },
+                })
+                : file;
+            await loadOsmFile(simpleTable, localFile, {
+                method: "loadGeoData()",
+                parameters: { file, options },
+                columns: options.columns,
+                conditions: options.conditions,
+            });
+            return;
+        }
+        catch (error) {
+            if (error instanceof SDAError) {
+                throw error;
+            }
+            throw new SDAError({
+                method: "loadGeoData()",
+                parameters: { file, options },
+                query: "",
+                cause: error,
+            });
+        }
+        finally {
+            if (temporaryFile !== undefined) {
+                rmSync(temporaryFile, { force: true });
+            }
+        }
+    }
+    const fileExtension = getExtension(file);
+    const selectColumns = options.columns !== undefined &&
+        options.columns.length > 0
+        ? options.columns.map(quoteIdentifier).join(", ")
+        : "*";
+    const spatialSetup = simpleTable.sdb.spatialLoaded
+        ? ""
+        : "INSTALL spatial; LOAD spatial; SET geometry_always_xy = true;";
+    const conditions = options.conditions ? ` WHERE ${options.conditions}` : "";
+    if (fileExtension === "geoparquet" || fileExtension === "parquet") {
+        await queryDB(simpleTable, `${spatialSetup}${file.toLowerCase().includes("http") ? " INSTALL https; LOAD https;" : ""}
+      CREATE OR REPLACE TABLE ${quoteIdentifier(simpleTable.name)} AS SELECT ${selectColumns} FROM read_parquet(${parseValue(file)})${conditions};`, mergeOptions(simpleTable, {
+            table: simpleTable.name,
+            method: "loadGeoData()",
+            parameters: { file, options },
+        }));
+    }
+    else {
+        await queryDB(simpleTable, `${spatialSetup}${file.toLowerCase().includes("http") ? " INSTALL https; LOAD https;" : ""}
+      CREATE OR REPLACE TABLE ${quoteIdentifier(simpleTable.name)} AS SELECT ${selectColumns} FROM ST_Read(${parseValue(file)})${conditions};`, mergeOptions(simpleTable, {
+            table: simpleTable.name,
+            method: "loadGeoData()",
+            parameters: { file, options },
+        }));
+    }
+    simpleTable.sdb.spatialLoaded = true;
+    const mayIncludeOgcFid = options.columns === undefined ||
+        options.columns.length === 0 || options.columns.includes("OGC_FID");
+    if (mayIncludeOgcFid && await simpleTable.hasColumn("OGC_FID")) {
+        await removeColumnsNow(simpleTable, ["OGC_FID"], "loadGeoData()");
+    }
+    if (options.toEPSG4326) {
+        const geoType = await simpleTable.getProjection("geom");
+        if (geoType !== "GEOMETRY('EPSG:4326')") {
+            // The reprojection runs directly (not with the sync reproject builder,
+            // which would queue for the next flush).
+            await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(simpleTable.name)} AS SELECT * REPLACE (ST_Transform("geom", 'EPSG:4326')::GEOMETRY('EPSG:4326') AS "geom") FROM ${quoteIdentifier(simpleTable.name)}`, mergeOptions(simpleTable, {
+                table: simpleTable.name,
+                method: "loadGeoData()",
+                parameters: { file, options },
+            }));
+        }
+    }
+}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadOSM.d.ts

@@ -0,0 +1,17 @@
+import type SimpleTable from "../class/SimpleTable.js";
+type BoundingBox = {
+    west: number;
+    south: number;
+    east: number;
+    north: number;
+};
+type LoadOsmOptions = {
+    filters: string | [string, string] | [string, string][];
+    endpoint?: string;
+    timeout?: number;
+    cache?: boolean;
+};
+export default function loadOSM(table: SimpleTable, bbox: BoundingBox, options: LoadOsmOptions): void;
+export declare function generateOverpassQuery(bbox: BoundingBox, filters: string[], timeout?: number): string;
+export {};
+//# sourceMappingURL=loadOSM.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadOSM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadOSM.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/loadOSM.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AASvD,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,cAAc,GAAG;IACpB,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,cAAc,GACtB,IAAI,CAkBN;AAgHD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,MAAM,CASR"}