@nshiab/simple-data-analysis 5.21.1 → 6.0.1

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

@@ -0,0 +1,112 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import parseType from "../helpers/parseTypes.js";
+import queueOp from "../helpers/queueOp.js";
+export default function convert(simpleTable, types, options = {}) {
+    types = structuredClone(types);
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "convert()",
+        parameters: { types, options },
+        needsSchema: true,
+        outputSchema: (allTypes) => ({
+            ...allTypes,
+            ...Object.fromEntries(Object.entries(types).map(([column, type]) => [
+                column,
+                parseType(type),
+            ])),
+        }),
+        values: (allTypes) => getDatetimeFormatValues(Object.keys(types), Object.values(types), Object.keys(allTypes), allTypes, options),
+        buildSelect: (input, allTypes) => {
+            const allColumns = Object.keys(allTypes);
+            for (const col in types) {
+                if (!allColumns.includes(col)) {
+                    throw new Error(`The column ${col} does not exist in the table.`);
+                }
+            }
+            return convertSelect(input, Object.keys(types), Object.values(types), allColumns, allTypes, options);
+        },
+    });
+}
+export function convertSelect(input, columns, columnsTypes, allColumns, allTypes, options) {
+    let query = `SELECT`;
+    const cast = options.strict === false ? "TRY_CAST" : "CAST";
+    for (const column of allColumns) {
+        const indexOf = columns.indexOf(column);
+        if (indexOf === -1) {
+            query += ` ${quoteIdentifier(column)},`;
+        }
+        else {
+            const expectedType = parseType(columnsTypes[indexOf]);
+            const currentType = allTypes[column];
+            const datetimeFormatExist = typeof options.datetimeFormat === "string";
+            const stringToNumber = currentType === "VARCHAR" &&
+                ["DOUBLE", "BIGINT"].includes(expectedType);
+            const stringToDate = currentType === "VARCHAR" &&
+                (expectedType.includes("TIME") || expectedType.includes("DATE"));
+            const dateToString = (currentType.includes("DATE") ||
+                currentType.includes("TIME")) &&
+                expectedType === "VARCHAR";
+            const timeToMs = currentType.includes("TIME") &&
+                ["DOUBLE", "BIGINT"].includes(expectedType);
+            const dateToMs = currentType.includes("DATE") &&
+                ["DOUBLE", "BIGINT"].includes(expectedType);
+            const msToTime = ["DOUBLE", "BIGINT"].includes(currentType) &&
+                expectedType === "TIME";
+            const msToDate = ["DOUBLE", "BIGINT"].includes(currentType) &&
+                expectedType.includes("DATE");
+            const msToTimestamp = ["DOUBLE", "BIGINT"].includes(currentType) &&
+                expectedType.includes("TIMESTAMP");
+            if (datetimeFormatExist && stringToDate) {
+                query += ` strptime(${quoteIdentifier(column)}, ?) AS ${quoteIdentifier(column)},`;
+            }
+            else if (datetimeFormatExist && dateToString) {
+                query += ` strftime(${quoteIdentifier(column)}, ?) AS ${quoteIdentifier(column)},`;
+            }
+            else if (timeToMs) {
+                query += ` date_part('epoch', ${quoteIdentifier(column)}) * 1000 AS ${quoteIdentifier(column)},`;
+            }
+            else if (dateToMs) {
+                query += ` epoch(${quoteIdentifier(column)}) * 1000 AS ${quoteIdentifier(column)},`;
+            }
+            else if (msToTime) {
+                query += ` TIME '00:00:00' + to_milliseconds(${quoteIdentifier(column)}) AS ${quoteIdentifier(column)},`;
+            }
+            else if (msToDate) {
+                query += ` DATE '1970-01-01' + to_milliseconds(${quoteIdentifier(column)}) AS ${quoteIdentifier(column)},`;
+            }
+            else if (msToTimestamp) {
+                query += ` TIMESTAMP '1970-01-01 00:00:00' + to_milliseconds(${quoteIdentifier(column)}) 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)},`;
+            }
+            else {
+                query += ` ${cast}(${quoteIdentifier(columns[indexOf])} AS ${parseType(columnsTypes[indexOf])}) AS ${quoteIdentifier(columns[indexOf])},`;
+            }
+        }
+    }
+    query = query.slice(0, query.length - 1);
+    query += ` FROM ${input}`;
+    return query;
+}
+function getDatetimeFormatValues(columns, columnsTypes, allColumns, allTypes, options) {
+    const datetimeFormat = options.datetimeFormat;
+    if (typeof datetimeFormat !== "string") {
+        return [];
+    }
+    return allColumns.flatMap((column) => {
+        const index = columns.indexOf(column);
+        if (index === -1) {
+            return [];
+        }
+        const currentType = allTypes[column];
+        const expectedType = parseType(columnsTypes[index]);
+        const stringToDate = currentType === "VARCHAR" &&
+            (expectedType.includes("TIME") || expectedType.includes("DATE"));
+        const dateToString = (currentType.includes("DATE") ||
+            currentType.includes("TIME")) && expectedType === "VARCHAR";
+        return stringToDate || dateToString ? [datetimeFormat] : [];
+    });
+}

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

@@ -0,0 +1,9 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function correlations(simpleTable: SimpleTable, options?: {
+    x?: string;
+    y?: string;
+    by?: string | string[];
+    decimals?: number;
+    outputTable?: string | boolean;
+}): SimpleTable;
+//# sourceMappingURL=correlations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"correlations.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/correlations.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE;IACP,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,GACL,WAAW,CA2Db"}

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

@@ -0,0 +1,86 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import getCombinations from "../helpers/getCombinations.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import queueOp from "../helpers/queueOp.js";
+import resolveOutputTable from "../helpers/resolveOutputTable.js";
+import stringToArray from "../helpers/stringToArray.js";
+import validateNumericalAnalysis from "../helpers/validateNumericalAnalysis.js";
+export default function correlations(simpleTable, options = {}) {
+    options = structuredClone(options);
+    options.outputTable = resolveOutputTable(simpleTable, options.outputTable);
+    if (typeof options.outputTable === "string") {
+        // The output table instance is created at call time so it can be
+        // returned synchronously and chained on right away.
+        const outputTable = simpleTable.sdb.newTable(options.outputTable);
+        queueOp(outputTable, {
+            kind: "barrier",
+            method: "correlations()",
+            parameters: { options },
+            execute: async () => {
+                const combinations = getCorrelationsCombinations(await simpleTable.getTypes(), options, simpleTable.name);
+                await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable.name)} AS ${correlationsSelect(`${quoteIdentifier(simpleTable.name)}`, combinations, options)}`, mergeOptions(simpleTable, {
+                    table: outputTable.name,
+                    method: "correlations()",
+                    parameters: {
+                        options,
+                        "combinations (computed)": combinations,
+                    },
+                    values: correlationsValues(combinations),
+                }));
+            },
+        });
+        return outputTable;
+    }
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "correlations()",
+        parameters: { options },
+        needsSchema: true,
+        values: (types) => correlationsValues(getCorrelationsCombinations(types, options, simpleTable.name)),
+        buildSelect: (input, types) => correlationsSelect(input, getCorrelationsCombinations(types, options, simpleTable.name), options),
+    });
+    return simpleTable;
+}
+function correlationsValues(combinations) {
+    return combinations.flatMap(([x, y]) => [x, y]);
+}
+function getCorrelationsCombinations(types, options, tableName) {
+    const columns = validateNumericalAnalysis(types, options, "correlations()", tableName);
+    let combinations = [];
+    if (options.x === undefined) {
+        combinations = getCombinations(columns, 2);
+    }
+    else if (options.y === undefined) {
+        combinations = [];
+        for (const col of columns) {
+            if (col !== options.x) {
+                combinations.push([options.x, col]);
+            }
+        }
+    }
+    else {
+        combinations = [[options.x, options.y]];
+    }
+    return combinations;
+}
+function correlationsSelect(input, combinations, options) {
+    const by = options.by ? stringToArray(options.by) : [];
+    const groupBy = by.length === 0
+        ? ""
+        : ` GROUP BY ${by.map((d) => `${quoteIdentifier(d)}`).join(",")}`;
+    const catSelect = by.length > 0
+        ? `${by.map((d) => `${quoteIdentifier(d)}`).join(",")}, `
+        : "";
+    // One UNION ALL branch per pair (each with a distinct pair of literals, so
+    // deduplication would never remove anything). DuckDB runs the branches as
+    // concurrent pipelines, which parallelizes the aggregates better than
+    // computing them all in one scan.
+    const branches = combinations.map((comb) => {
+        const expression = typeof options.decimals === "number"
+            ? `ROUND(corr(${quoteIdentifier(comb[0])}, ${quoteIdentifier(comb[1])}), ${options.decimals})`
+            : `corr(${quoteIdentifier(comb[0])}, ${quoteIdentifier(comb[1])})`;
+        return `SELECT ${catSelect}? AS ${quoteIdentifier("x")}, ? AS ${quoteIdentifier("y")}, ${expression} AS ${quoteIdentifier("corr")} FROM ${input}${groupBy}`;
+    });
+    return branches.join("\nUNION ALL\n");
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"coveredBy.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/coveredBy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,MAAM,EACvB,SAAS,EAAE,MAAM,QAelB"}

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

@@ -0,0 +1,16 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import assertNewColumns from "../helpers/assertNewColumns.js";
+import queueOp from "../helpers/queueOp.js";
+export default function coveredBy(simpleTable, column, containerColumn, newColumn) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "coveredBy()",
+        parameters: { column, containerColumn, newColumn },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            assertNewColumns(types, [newColumn], "coveredBy()");
+            return `SELECT *, CAST(ST_Covers(${quoteIdentifier(containerColumn)}, ${quoteIdentifier(column)}) AS BOOLEAN) AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}

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

@@ -0,0 +1,24 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function createFtsIndex(simpleTable: SimpleTable, idColumn: string, textColumn: string, options?: {
+    stemmer?: "arabic" | "basque" | "catalan" | "danish" | "dutch" | "english" | "finnish" | "french" | "german" | "greek" | "hindi" | "hungarian" | "indonesian" | "irish" | "italian" | "lithuanian" | "nepali" | "norwegian" | "porter" | "portuguese" | "romanian" | "russian" | "serbian" | "spanish" | "swedish" | "tamil" | "turkish" | "none";
+    stopwords?: string;
+    ignore?: string;
+    stripAccents?: boolean;
+    lower?: boolean;
+    overwrite?: boolean;
+    verbose?: boolean;
+}): void;
+/**
+ * Creates the index immediately, without queueing. For use inside a
+ * barrier's execute, which runs during a flush.
+ */
+export declare function executeCreateFtsIndex(simpleTable: SimpleTable, idColumn: string, textColumn: string, options: {
+    stemmer?: string;
+    stopwords?: string;
+    ignore?: string;
+    stripAccents?: boolean;
+    lower?: boolean;
+    overwrite?: boolean;
+    verbose?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=createFtsIndex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createFtsIndex.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/createFtsIndex.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,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,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,QAWP;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,WAAW,EACxB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE;IACP,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GACA,OAAO,CAAC,IAAI,CAAC,CAgEf"}

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

@@ -0,0 +1,67 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import camelCase from "../helpers/camelCase.js";
+import queueOp from "../helpers/queueOp.js";
+import buildCreateIndexQuery from "../helpers/indexQueries.js";
+export default function createFtsIndex(simpleTable, idColumn, textColumn, options = {}) {
+    // Index creation is multi-statement by nature: it executes as a barrier.
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "barrier",
+        method: "createFtsIndex()",
+        parameters: { idColumn, textColumn, options },
+        execute: () => executeCreateFtsIndex(simpleTable, idColumn, textColumn, options),
+    });
+}
+/**
+ * Creates the index immediately, without queueing. For use inside a
+ * barrier's execute, which runs during a flush.
+ */
+export async function executeCreateFtsIndex(simpleTable, idColumn, textColumn, options) {
+    const indexName = `fts_index_${camelCase(simpleTable.name)}`;
+    const indexPosition = simpleTable.indexes.findIndex(({ name }) => name === indexName);
+    const indexExists = indexPosition >= 0;
+    if (indexExists && options.overwrite) {
+        options.verbose &&
+            console.log(`\nDropping existing FTS index on ${quoteIdentifier(textColumn)} column...`);
+        await simpleTable.sdb.customQuery(`PRAGMA drop_fts_index(${quoteIdentifier(simpleTable.name)});`);
+        options.verbose && console.log("FTS index dropped.");
+    }
+    if (!indexExists || options.overwrite) {
+        options.verbose &&
+            console.log(`\nCreating FTS index on ${quoteIdentifier(textColumn)} column...`);
+        const indexOptions = {};
+        if (options.stemmer !== undefined) {
+            indexOptions.stemmer = options.stemmer;
+        }
+        if (options.stopwords !== undefined) {
+            indexOptions.stopwords = options.stopwords;
+        }
+        if (options.ignore !== undefined) {
+            indexOptions.ignore = options.ignore;
+        }
+        if (options.stripAccents !== undefined) {
+            indexOptions.stripAccents = options.stripAccents;
+        }
+        if (options.lower !== undefined) {
+            indexOptions.lower = options.lower;
+        }
+        const definition = {
+            kind: "fts",
+            name: indexName,
+            idColumn,
+            textColumn,
+            options: indexOptions,
+        };
+        await simpleTable.sdb.customQuery(buildCreateIndexQuery(simpleTable.name, definition));
+        if (indexExists) {
+            simpleTable.indexes[indexPosition] = definition;
+        }
+        else {
+            simpleTable.indexes.push(definition);
+        }
+        options.verbose && console.log("FTS index created successfully.");
+    }
+    else {
+        options.verbose && console.log("FTS index already exists.");
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPoints.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/createPoints.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,QA0BtC"}

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

@@ -0,0 +1,23 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import parseValue from "../helpers/parseValue.js";
+import queueOp from "../helpers/queueOp.js";
+export default function createPoints(simpleTable, latColumn, lonColumn, newColumn, options = {}) {
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "createPoints()",
+        parameters: { latColumn, lonColumn, newColumn, options },
+        needsSchema: true,
+        needsSpatial: true,
+        outputSchema: (types) => ({
+            ...types,
+            [newColumn]: `GEOMETRY('${options.projection ?? "EPSG:4326"}')`,
+        }),
+        buildSelect: (input, types) => {
+            const expression = `ST_Point(${quoteIdentifier(lonColumn)}, ${quoteIdentifier(latColumn)})::GEOMETRY(${parseValue(options.projection ?? "EPSG:4326")})`;
+            return Object.keys(types).includes(newColumn)
+                ? `SELECT * REPLACE (${expression} AS ${quoteIdentifier(newColumn)}) FROM ${input}`
+                : `SELECT *, ${expression} AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}

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

@@ -0,0 +1,9 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function createVssIndex(simpleTable: SimpleTable, column: string, options?: {
+    overwrite?: boolean;
+    verbose?: boolean;
+    efConstruction?: number;
+    efSearch?: number;
+    M?: number;
+}): void;
+//# sourceMappingURL=createVssIndex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createVssIndex.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/createVssIndex.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,CAAC,CAAC,EAAE,MAAM,CAAC;CACP,QAUP"}

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

@@ -0,0 +1,59 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import camelCase from "../helpers/camelCase.js";
+import queueOp from "../helpers/queueOp.js";
+import buildCreateIndexQuery from "../helpers/indexQueries.js";
+export default function createVssIndex(simpleTable, column, options = {}) {
+    // Index creation is multi-statement by nature: it executes as a barrier.
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "barrier",
+        method: "createVssIndex()",
+        parameters: { column, options },
+        execute: () => executeCreateVssIndex(simpleTable, column, options),
+    });
+}
+async function executeCreateVssIndex(simpleTable, column, options) {
+    const indexName = `vss_cosine_index_${camelCase(simpleTable.name)}`;
+    const indexPosition = simpleTable.indexes.findIndex(({ name }) => name === indexName);
+    const indexExists = indexPosition >= 0;
+    if (indexExists && options.overwrite) {
+        options.verbose &&
+            console.log(`\nDropping existing VSS index on ${quoteIdentifier(column)} column...`);
+        await simpleTable.sdb.customQuery(`DROP INDEX IF EXISTS ${indexName};`);
+        options.verbose && console.log("VSS index dropped.");
+    }
+    if (!indexExists || options.overwrite) {
+        options.verbose &&
+            console.log(`\nCreating VSS index on ${quoteIdentifier(column)} column...`);
+        const indexOptions = {};
+        if (options.efConstruction !== undefined) {
+            indexOptions.efConstruction = options.efConstruction;
+        }
+        if (options.efSearch !== undefined) {
+            indexOptions.efSearch = options.efSearch;
+        }
+        if (options.M !== undefined) {
+            indexOptions.M = options.M;
+        }
+        const definition = {
+            kind: "vss",
+            name: indexName,
+            column,
+            options: indexOptions,
+        };
+        await simpleTable.sdb.customQuery(`INSTALL vss; LOAD vss;${simpleTable.sdb.file !== ":memory:"
+            ? "\nSET hnsw_enable_experimental_persistence=true;"
+            : ""}
+      ${buildCreateIndexQuery(simpleTable.name, definition)}`);
+        if (indexExists) {
+            simpleTable.indexes[indexPosition] = definition;
+        }
+        else {
+            simpleTable.indexes.push(definition);
+        }
+        options.verbose && console.log("VSS index created successfully.");
+    }
+    else {
+        options.verbose && console.log("VSS index already exists.");
+    }
+}

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

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

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

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

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

@@ -0,0 +1,35 @@
+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 resolveOutputTable from "../helpers/resolveOutputTable.js";
+import assertSameDatabase from "../helpers/assertSameDatabase.js";
+export default function crossJoin(simpleTable, rightTable, options = {}) {
+    assertSameDatabase(simpleTable.sdb, [rightTable], "crossJoin()");
+    options = structuredClone(options);
+    options.outputTable = resolveOutputTable(simpleTable, options.outputTable);
+    // The output table instance is created at call time so it can be returned
+    // synchronously and chained on right away.
+    const outputTable = typeof options.outputTable === "string"
+        ? simpleTable.sdb.newTable(options.outputTable)
+        : simpleTable;
+    queueOp(outputTable, {
+        kind: "barrier",
+        method: "crossJoin()",
+        parameters: { rightTable: rightTable.name, options },
+        execute: () => executeCrossJoin(simpleTable, rightTable, outputTable),
+    });
+    return outputTable;
+}
+async function executeCrossJoin(simpleTable, rightTable, outputTable) {
+    const identicalColumns = getIdenticalColumns(await simpleTable.getColumns(), await rightTable.getColumns());
+    if (identicalColumns.length > 0) {
+        throw new Error(`The tables have columns with identical names. Rename or remove ${identicalColumns.map((d) => `${quoteIdentifier(d)}`).join(", ")} in one of the two tables before doing the cross join.`);
+    }
+    await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable.name)} AS SELECT ${quoteIdentifier(simpleTable.name)}.*, ${quoteIdentifier(rightTable.name)}.* FROM ${quoteIdentifier(simpleTable.name)} CROSS JOIN ${quoteIdentifier(rightTable.name)};`, mergeOptions(simpleTable, {
+        table: outputTable.name,
+        method: "crossJoin()",
+        parameters: { rightTable: rightTable.name },
+    }));
+}

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

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

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

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

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

@@ -0,0 +1,19 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import queueOp from "../helpers/queueOp.js";
+export default function difference(simpleTable, column1, column2, newColumn) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "difference()",
+        parameters: { column1, column2, newColumn },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            // The schema type carries the projection (e.g. GEOMETRY('EPSG:4326')),
+            // so the cast keeps it on the new geometries.
+            const expression = `ST_Difference(${quoteIdentifier(column1)}, ${quoteIdentifier(column2)})::${types[column1]}`;
+            return Object.keys(types).includes(newColumn)
+                ? `SELECT * REPLACE (${expression} AS ${quoteIdentifier(newColumn)}) FROM ${input}`
+                : `SELECT *, ${expression} AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}

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

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

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

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

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

@@ -0,0 +1,48 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import assertNewColumns from "../helpers/assertNewColumns.js";
+import queueOp from "../helpers/queueOp.js";
+export default function distance(simpleTable, column1, column2, newColumn, options = {}) {
+    // Building the expression doesn't need the database, so invalid options
+    // throw at call time.
+    const expression = distanceExpression(column1, column2, options);
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "distance()",
+        parameters: { column1, column2, newColumn },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            assertNewColumns(types, [newColumn], "distance()");
+            return `SELECT *, CAST(${expression} AS DOUBLE) AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}
+function distanceExpression(column1, column2, options = {}) {
+    options = structuredClone(options);
+    options.method = options.method ?? "srs";
+    if (options.method === "srs" && typeof options.unit === "string") {
+        throw new Error("Using the SRS unit. You can't specify options.unit unless you set options.method to 'spheroid' or 'haversine'.");
+    }
+    else if (["spheroid", "haversine"].includes(options.method)) {
+        options.unit = options.unit ?? "m";
+        if (!["m", "km"].includes(options.unit)) {
+            throw new Error(`Unknown unit ${options.unit}. Choose between 'm' and 'km'.`);
+        }
+    }
+    let expression = "";
+    if (options.method === "srs") {
+        expression = `ST_Distance(${quoteIdentifier(column1)}, ${quoteIdentifier(column2)})`;
+    }
+    else if (options.method === "haversine") {
+        expression = `ST_Distance_Sphere(${quoteIdentifier(column1)}, ${quoteIdentifier(column2)}) ${options.unit === "km" ? "/ 1000" : ""}`;
+    }
+    else if (options.method === "spheroid") {
+        expression = `ST_Distance_Spheroid(${quoteIdentifier(column1)}::GEOMETRY, ${quoteIdentifier(column2)}::GEOMETRY) ${options.unit === "km" ? "/ 1000" : ""}`;
+    }
+    else {
+        throw new Error(`distance() received an unknown method: ${options.method}. Choose "srs", "haversine", or "spheroid".`);
+    }
+    return typeof options.decimals === "number"
+        ? `ROUND(${expression}, ${options.decimals})`
+        : expression;
+}

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

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

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

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

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

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