@nshiab/simple-data-analysis-core 2.1.12 → 2.1.13

package/esm/methods/indexValues.d.ts

@@ -1,27 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-declare const indexValueStats: readonly ["min", "max", "mean", "median"];
-type IndexValueStat = (typeof indexValueStats)[number];
-type IndexValueReference = {
-    stat: IndexValueStat;
-    column?: never;
-    equals?: never;
-    at?: never;
-} | {
-    column: string;
-    equals: string | number | bigint | boolean | Date;
-    stat?: never;
-    at?: never;
-} | {
-    column: string;
-    at: "min" | "max";
-    stat?: never;
-    equals?: never;
-};
-type IndexValueOptions = {
-    by?: string | string[];
-    base?: number;
-    decimals?: number;
-};
-export default function indexValues(simpleTable: SimpleTable, column: string, newColumn: string, reference: IndexValueReference, options?: IndexValueOptions): void;
-export {};
-//# sourceMappingURL=indexValues.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"indexValues.d.ts","sourceRoot":"","sources":["../../src/methods/indexValues.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,QAAA,MAAM,eAAe,2CAKe,CAAC;AAErC,KAAK,cAAc,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD,KAAK,mBAAmB,GACpB;IACA,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,EAAE,CAAC,EAAE,KAAK,CAAC;CACZ,GACC;IACA,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IAClD,IAAI,CAAC,EAAE,KAAK,CAAC;IACb,EAAE,CAAC,EAAE,KAAK,CAAC;CACZ,GACC;IACA,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,KAAK,GAAG,KAAK,CAAC;IAClB,IAAI,CAAC,EAAE,KAAK,CAAC;IACb,MAAM,CAAC,EAAE,KAAK,CAAC;CAChB,CAAC;AAEJ,KAAK,iBAAiB,GAAG;IACvB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,mBAAmB,EAC9B,OAAO,GAAE,iBAAsB,QA0PhC"}

package/esm/methods/indexValues.js

@@ -1,281 +0,0 @@
-import assertNewColumns from "../helpers/assertNewColumns.js";
-import assertColumnsExist from "../helpers/assertColumnsExist.js";
-import getStatExpression from "../helpers/getStatExpression.js";
-import keepNumericalColumns from "../helpers/keepNumericalColumns.js";
-import queueOp from "../helpers/queueOp.js";
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import stringToArray from "../helpers/stringToArray.js";
-import toDuckDBValue from "../helpers/toDuckDBValue.js";
-import { DuckDBTimestampTZValue } from "@duckdb/node-api";
-const indexValueStats = [
-    "min",
-    "max",
-    "mean",
-    "median",
-];
-export default function indexValues(simpleTable, column, newColumn, reference, options = {}) {
-    validateReference(reference);
-    if (options.base !== undefined &&
-        (!Number.isFinite(options.base) || options.base <= 0)) {
-        throw new Error("indexValues() options.base must be a finite number greater than 0.");
-    }
-    if (options.decimals !== undefined &&
-        (!Number.isFinite(options.decimals) ||
-            !Number.isInteger(options.decimals) || options.decimals < 0)) {
-        throw new Error("indexValues() options.decimals must be a finite integer greater than or equal to 0.");
-    }
-    reference = structuredClone(reference);
-    options = structuredClone(options);
-    const columnReference = typeof reference.column === "string"
-        ? reference
-        : undefined;
-    const exactReference = columnReference?.equals !== undefined
-        ? columnReference
-        : undefined;
-    const columnAtReference = columnReference?.at !== undefined
-        ? columnReference
-        : undefined;
-    const statReference = columnReference === undefined
-        ? reference
-        : undefined;
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "indexValues()",
-        parameters: { column, newColumn, reference, options },
-        needsSchema: true,
-        values: exactReference === undefined ? undefined : (schema) => [
-            bindReferenceValue(exactReference.equals, schema[exactReference.column]),
-        ],
-        buildSelect: (input, schema) => {
-            assertNewColumns(schema, [newColumn], "indexValues()");
-            const by = options.by ? stringToArray(options.by) : [];
-            assertColumnsExist(schema, [
-                column,
-                ...by,
-                ...(columnReference === undefined ? [] : [columnReference.column]),
-            ], "indexValues()");
-            if (!keepNumericalColumns(schema).includes(column)) {
-                throw new Error(`indexValues() requires a numeric column, but ${quoteIdentifier(column)} has type ${schema[column]}. Convert ${quoteIdentifier(column)} to a numeric type first.`);
-            }
-            if (exactReference !== undefined) {
-                validateExactReferenceValueType(exactReference.equals, exactReference.column, schema[exactReference.column]);
-            }
-            const partition = by.length === 0
-                ? ""
-                : `PARTITION BY ${by.map(quoteIdentifier).join(", ")}`;
-            const quotedColumn = quoteIdentifier(column);
-            if (columnAtReference !== undefined) {
-                const rowOrderColumn = temporaryColumn(schema, "__sda_index_row_order");
-                const extremeColumn = temporaryColumn(schema, "__sda_index_extreme", [rowOrderColumn]);
-                const matchCountColumn = temporaryColumn(schema, "__sda_index_match_count", [rowOrderColumn, extremeColumn]);
-                const referenceValueColumn = temporaryColumn(schema, "__sda_index_reference_value", [rowOrderColumn, extremeColumn, matchCountColumn]);
-                const quotedRowOrderColumn = quoteIdentifier(rowOrderColumn);
-                const quotedExtremeColumn = quoteIdentifier(extremeColumn);
-                const quotedMatchCountColumn = quoteIdentifier(matchCountColumn);
-                const quotedReferenceValueColumn = quoteIdentifier(referenceValueColumn);
-                const quotedReferenceColumn = quoteIdentifier(columnAtReference.column);
-                const sourceAlias = quoteIdentifier("__sda_index_source");
-                const extremaAlias = quoteIdentifier("__sda_index_extrema");
-                const referenceAlias = quoteIdentifier("__sda_index_reference");
-                const calculatedAlias = quoteIdentifier("__sda_index_calculated");
-                const qualify = (alias, selectedColumn) => `${alias}.${quoteIdentifier(selectedColumn)}`;
-                const sourceColumn = qualify(sourceAlias, column);
-                const calculatedReferenceValue = qualify(calculatedAlias, referenceValueColumn);
-                const calculatedMatchCount = qualify(calculatedAlias, matchCountColumn);
-                const expression = getIndexedExpression(sourceColumn, calculatedReferenceValue, options.base ?? 100, options.decimals, calculatedMatchCount);
-                const extremaBySelect = by.length === 0
-                    ? ""
-                    : `${by.map(quoteIdentifier).join(", ")}, `;
-                const extremaGroupBy = by.length === 0
-                    ? ""
-                    : ` GROUP BY ${by.map(quoteIdentifier).join(", ")}`;
-                const extremaJoin = [
-                    ...by.map((byColumn) => `${qualify(referenceAlias, byColumn)} IS NOT DISTINCT FROM ${qualify(extremaAlias, byColumn)}`),
-                    `${qualify(referenceAlias, columnAtReference.column)} = ${qualify(extremaAlias, extremeColumn)}`,
-                ].join(" AND ");
-                const calculatedBySelect = by.length === 0
-                    ? ""
-                    : `${by.map((byColumn) => qualify(extremaAlias, byColumn)).join(", ")}, `;
-                const calculatedGroupBy = by.length === 0
-                    ? ""
-                    : ` GROUP BY ${by.map((byColumn) => qualify(extremaAlias, byColumn)).join(", ")}`;
-                const calculatedSubquery = `(SELECT ${calculatedBySelect}
-            COUNT(${qualify(referenceAlias, columnAtReference.column)}) AS ${quotedMatchCountColumn},
-            MAX(${qualify(referenceAlias, column)}) AS ${quotedReferenceValueColumn}
-          FROM (
-            SELECT ${extremaBySelect}${columnAtReference.at.toUpperCase()}(${quotedReferenceColumn}) AS ${quotedExtremeColumn}
-            FROM ${input}${extremaGroupBy}
-          ) AS ${extremaAlias}
-          LEFT JOIN ${input} AS ${referenceAlias} ON ${extremaJoin}${calculatedGroupBy}) AS ${calculatedAlias}`;
-                const sourceJoin = by.length === 0
-                    ? `CROSS JOIN ${calculatedSubquery}`
-                    : `LEFT JOIN ${calculatedSubquery} ON ${by.map((byColumn) => `${qualify(sourceAlias, byColumn)} IS NOT DISTINCT FROM ${qualify(calculatedAlias, byColumn)}`).join(" AND ")}`;
-                return `SELECT ${sourceAlias}.* EXCLUDE (${quotedRowOrderColumn}),
-          ${expression} AS ${quoteIdentifier(newColumn)}
-        FROM (SELECT *, ROW_NUMBER() OVER () AS ${quotedRowOrderColumn} FROM ${input}) AS ${sourceAlias}
-        ${sourceJoin}
-        ORDER BY ${qualify(sourceAlias, rowOrderColumn)}`;
-            }
-            if (exactReference !== undefined) {
-                const matchColumn = temporaryColumn(schema, "__sda_index_match");
-                const matchCountColumn = temporaryColumn(schema, "__sda_index_match_count", [matchColumn]);
-                const referenceValueColumn = temporaryColumn(schema, "__sda_index_reference_value", [matchColumn, matchCountColumn]);
-                const quotedMatchColumn = quoteIdentifier(matchColumn);
-                const quotedMatchCountColumn = quoteIdentifier(matchCountColumn);
-                const quotedReferenceValueColumn = quoteIdentifier(referenceValueColumn);
-                const expression = getIndexedExpression(quotedColumn, quotedReferenceValueColumn, options.base ?? 100, options.decimals, quotedMatchCountColumn);
-                const quotedReferenceColumn = quoteIdentifier(exactReference.column);
-                const matchInput = `SELECT *, ${quotedReferenceColumn} = ? AS ${quotedMatchColumn}
-            FROM ${input}`;
-                const excludedColumns = [
-                    quotedMatchColumn,
-                    quotedMatchCountColumn,
-                    quotedReferenceValueColumn,
-                ].join(", ");
-                return `SELECT * EXCLUDE (${excludedColumns}),
-          ${expression} AS ${quoteIdentifier(newColumn)}
-        FROM (
-          SELECT *,
-            COUNT(*) FILTER (WHERE ${quotedMatchColumn}) OVER (${partition}) AS ${quotedMatchCountColumn},
-            MAX(${quotedColumn}) FILTER (WHERE ${quotedMatchColumn}) OVER (${partition}) AS ${quotedReferenceValueColumn}
-          FROM (
-            ${matchInput}
-          )
-        )`;
-            }
-            const referenceValue = getWindowStatExpression(statReference.stat, schema[column], quotedColumn, partition);
-            const referenceValueColumn = temporaryColumn(schema, "__sda_index_reference_value");
-            const quotedReferenceValueColumn = quoteIdentifier(referenceValueColumn);
-            const expression = getIndexedExpression(quotedColumn, quotedReferenceValueColumn, options.base ?? 100, options.decimals);
-            return `SELECT * EXCLUDE (${quotedReferenceValueColumn}),
-        ${expression} AS ${quoteIdentifier(newColumn)}
-      FROM (
-        SELECT *, ${referenceValue} AS ${quotedReferenceValueColumn}
-        FROM ${input}
-      )`;
-        },
-    });
-}
-function validateReference(reference) {
-    if (reference === null || typeof reference !== "object") {
-        throw new Error("indexValues() reference must contain stat, column and equals, or column and at.");
-    }
-    if (typeof reference.column !== "string") {
-        if (reference.stat === undefined || reference.equals !== undefined ||
-            reference.at !== undefined) {
-            throw new Error("indexValues() reference must contain stat, column and equals, or column and at.");
-        }
-        if (!indexValueStats.includes(reference.stat)) {
-            throw new Error(`indexValues() reference.stat must be one of ${indexValueStats.map((stat) => JSON.stringify(stat)).join(", ")}.`);
-        }
-        return;
-    }
-    if (reference.stat !== undefined) {
-        throw new Error("indexValues() reference.stat cannot be provided with reference.column. Use reference.at to select the minimum or maximum row.");
-    }
-    const hasAt = reference.at !== undefined;
-    const hasEquals = reference.equals !== undefined;
-    if (hasAt === hasEquals) {
-        throw new Error(hasAt
-            ? "indexValues() reference cannot contain both equals and at."
-            : "indexValues() reference must contain stat, column and equals, or column and at.");
-    }
-    if (hasAt) {
-        if (!(reference.at === "min" || reference.at === "max")) {
-            throw new Error('indexValues() reference.at must be "min" or "max".');
-        }
-        return;
-    }
-    if (reference.equals === null || reference.equals === undefined) {
-        throw new Error("indexValues() reference.equals cannot be null or undefined.");
-    }
-    const valueType = typeof reference.equals;
-    if (!(reference.equals instanceof Date) &&
-        !["string", "number", "bigint", "boolean"].includes(valueType)) {
-        throw new Error("indexValues() reference.equals must be a string, number, bigint, boolean, or Date.");
-    }
-    if (typeof reference.equals === "number" && Number.isNaN(reference.equals)) {
-        throw new Error("indexValues() reference.equals cannot be NaN.");
-    }
-    if (reference.equals instanceof Date &&
-        Number.isNaN(reference.equals.getTime())) {
-        throw new Error("indexValues() reference.equals must be a valid Date.");
-    }
-}
-function validateExactReferenceValueType(value, column, columnType) {
-    const valueType = value instanceof Date ? "Date" : typeof value;
-    let expected;
-    let valid = true;
-    if (columnType === "VARCHAR" || columnType === "UUID" ||
-        columnType.startsWith("ENUM(")) {
-        expected = "a string";
-        valid = typeof value === "string";
-    }
-    else if (columnType === "BOOLEAN") {
-        expected = "a boolean";
-        valid = typeof value === "boolean";
-    }
-    else if (columnType === "BIGNUM" ||
-        keepNumericalColumns({ [column]: columnType }).includes(column)) {
-        expected = "a number or bigint";
-        valid = typeof value === "number" || typeof value === "bigint";
-    }
-    else if ([
-        "DATE",
-        "TIMESTAMP",
-        "TIMESTAMP_S",
-        "TIMESTAMP_MS",
-        "TIMESTAMP_NS",
-        "TIMESTAMP WITH TIME ZONE",
-    ].includes(columnType)) {
-        expected = "a string or Date";
-        valid = typeof value === "string" || value instanceof Date;
-    }
-    else if (["TIME", "TIME WITH TIME ZONE", "INTERVAL"].includes(columnType)) {
-        expected = "a string";
-        valid = typeof value === "string";
-    }
-    if (!valid) {
-        throw new Error(`indexValues() reference.equals must be ${expected} for column ${quoteIdentifier(column)} with type ${columnType}, but received ${valueType}.`);
-    }
-}
-function getIndexedExpression(sourceValue, referenceValue, base, decimals, matchCount) {
-    const indexedValue = `${sourceValue} / ${referenceValue} * ${base}`;
-    const calculatedValue = decimals === undefined
-        ? indexedValue
-        : `ROUND(${indexedValue}, ${decimals})`;
-    const referenceAction = matchCount === undefined ? "calculated" : "found";
-    const cardinalityChecks = matchCount === undefined
-        ? ""
-        : `WHEN ${matchCount} = 0 THEN error('indexValues() found no reference row for at least one group.')
-    WHEN ${matchCount} > 1 THEN error('indexValues() found multiple reference rows for at least one group.')
-    `;
-    return `CASE
-    ${cardinalityChecks}WHEN ${referenceValue} IS NULL THEN error('indexValues() ${referenceAction} a null reference value for at least one group.')
-    WHEN ${referenceValue} = 0 THEN error('indexValues() ${referenceAction} a zero reference value for at least one group.')
-    WHEN ${sourceValue} IS NULL THEN NULL
-    ELSE ${calculatedValue}
-  END`;
-}
-function getWindowStatExpression(stat, columnType, quotedColumn, partition) {
-    const aggregate = getStatExpression(stat, columnType, quotedColumn, undefined);
-    if (aggregate === null) {
-        throw new Error(`indexValues() cannot calculate ${stat} for column ${quotedColumn} with type ${columnType}.`);
-    }
-    return `${aggregate} OVER (${partition})`;
-}
-function bindReferenceValue(value, columnType) {
-    if (value instanceof Date &&
-        columnType?.includes("TIMESTAMP WITH TIME ZONE")) {
-        return new DuckDBTimestampTZValue(BigInt(value.getTime()) * 1000n);
-    }
-    return toDuckDBValue(value);
-}
-function temporaryColumn(schema, base, reserved = []) {
-    let column = base;
-    let suffix = 1;
-    while (schema[column] !== undefined || reserved.includes(column)) {
-        column = `${base}_${suffix++}`;
-    }
-    return column;
-}

package/esm/methods/insertRows.d.ts

@@ -1,5 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function insertRows(simpleTable: SimpleTable, rows: {
-    [key: string]: unknown;
-}[]): void;
-//# sourceMappingURL=insertRows.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"insertRows.d.ts","sourceRoot":"","sources":["../../src/methods/insertRows.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,QA4BnC"}

package/esm/methods/insertRows.js

@@ -1,41 +0,0 @@
-import mergeOptions from "../helpers/mergeOptions.js";
-import queryDB from "../helpers/queryDB.js";
-import queueOp from "../helpers/queueOp.js";
-import { executePreparedArray, prepareArray } from "./loadArray.js";
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import toDuckDBValue from "../helpers/toDuckDBValue.js";
-export default function insertRows(simpleTable, rows) {
-    const prepared = prepareArray(rows);
-    const statement = insertRowsStatement(simpleTable.name, rows);
-    // Whether the rows are inserted or loaded depends on the table existing,
-    // so insertRows can't be expressed as a single SELECT over its input: it
-    // executes as a barrier.
-    queueOp(simpleTable, {
-        kind: "barrier",
-        method: "insertRows()",
-        parameters: { rows: `${rows.length} rows` },
-        execute: async () => {
-            if (await simpleTable.sdb.hasTable(simpleTable.name)) {
-                await queryDB(simpleTable, statement.query, mergeOptions(simpleTable, {
-                    table: simpleTable.name,
-                    method: "insertRows()",
-                    parameters: { rows: `${rows.length} rows` },
-                    values: statement.values,
-                }));
-            }
-            else {
-                await executePreparedArray(simpleTable, prepared);
-            }
-        },
-    });
-}
-function insertRowsStatement(table, rows) {
-    const columns = Object.keys(rows[0]);
-    const values = rows.flatMap((row) => columns.map((column) => toDuckDBValue(row[column])));
-    let query = `INSERT INTO ${quoteIdentifier(table)} (${columns.map(quoteIdentifier).join(", ")})
-        VALUES`;
-    for (const _row of rows) {
-        query += `\n(${columns.map(() => "?").join(", ")}),`;
-    }
-    return { query: query.slice(0, query.length - 1), values };
-}

package/esm/methods/insertTables.d.ts

@@ -1,5 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function insertTables(simpleTable: SimpleTable, tables: SimpleTable | SimpleTable[], options?: {
-    unifyColumns?: boolean;
-}): void;
-//# sourceMappingURL=insertTables.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"insertTables.d.ts","sourceRoot":"","sources":["../../src/methods/insertTables.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAIvD,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,WAAW,GAAG,WAAW,EAAE,EACnC,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,QAezC"}

package/esm/methods/insertTables.js

@@ -1,99 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import ensureSpatial from "../helpers/ensureSpatial.js";
-import mergeOptions from "../helpers/mergeOptions.js";
-import queryDB from "../helpers/queryDB.js";
-import queueOp from "../helpers/queueOp.js";
-import removeColumnsNow from "../helpers/removeColumnsNow.js";
-import unifyColumns from "../helpers/unifyColumns.js";
-import assertSameDatabase from "../helpers/assertSameDatabase.js";
-export default function insertTables(simpleTable, tables, options = {}) {
-    const array = Array.isArray(tables) ? [...tables] : [tables];
-    assertSameDatabase(simpleTable.sdb, array, "insertTables()");
-    options = structuredClone(options);
-    queueOp(simpleTable, {
-        kind: "barrier",
-        method: "insertTables()",
-        parameters: {
-            tables: array.map((t) => t.name),
-            options,
-        },
-        execute: () => executeInsertTables(simpleTable, array, options),
-    });
-}
-async function executeInsertTables(simpleTable, array, options) {
-    if (!await simpleTable.sdb.hasTable(simpleTable.name)) {
-        // The table is created directly (not with the sync setTypes builder,
-        // which would queue for the next flush).
-        const firstTableTypes = await array[0].getTypes();
-        if (Object.values(firstTableTypes)
-            .map((d) => d.toLowerCase())
-            .some((d) => d.startsWith("geometry"))) {
-            await ensureSpatial(simpleTable);
-        }
-        await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(simpleTable.name)} (${Object.keys(firstTableTypes)
-            .map((d) => `${quoteIdentifier(d)} ${firstTableTypes[d]}`)
-            .join(", ")});`, mergeOptions(simpleTable, {
-            table: simpleTable.name,
-            method: "insertTables()",
-            parameters: { types: firstTableTypes },
-        }));
-    }
-    // Checking columns, types
-    if (!options.unifyColumns) {
-        const thisColumns = (await simpleTable.getColumns()).sort();
-        const thisColumnSet = new Set(thisColumns);
-        for (const table of array) {
-            const tableColumns = (await table.getColumns()).sort();
-            const tableColumnSet = new Set(tableColumns);
-            const missingFromTable = thisColumns.filter((column) => !tableColumnSet.has(column));
-            const missingFromSimpleTable = tableColumns.filter((column) => !thisColumnSet.has(column));
-            if (missingFromTable.length > 0 || missingFromSimpleTable.length > 0) {
-                const differences = [];
-                if (missingFromTable.length > 0) {
-                    differences.push(`${missingFromTable.length} column${missingFromTable.length === 1 ? "" : "s"} missing from ${quoteIdentifier(table.name)}: ${missingFromTable.map(quoteIdentifier).join(", ")}.`);
-                }
-                if (missingFromSimpleTable.length > 0) {
-                    differences.push(`${missingFromSimpleTable.length} column${missingFromSimpleTable.length === 1 ? "" : "s"} missing from ${quoteIdentifier(simpleTable.name)}: ${missingFromSimpleTable.map(quoteIdentifier).join(", ")}.`);
-                }
-                throw new Error(`Tables ${quoteIdentifier(simpleTable.name)} and ${quoteIdentifier(table.name)} do not have the same columns.\n${differences.join("\n")}\nPass { unifyColumns: true } to fill missing columns with NULL values.`);
-            }
-        }
-    }
-    const allTables = [simpleTable, ...array];
-    const allTypes = {};
-    const typeSourceTables = {};
-    for (const table of allTables) {
-        const types = await table.getTypes();
-        for (const key in types) {
-            if (!allTypes[key]) {
-                allTypes[key] = types[key];
-                typeSourceTables[key] = table;
-            }
-            else {
-                if (allTypes[key] !== types[key]) {
-                    const sourceTable = typeSourceTables[key];
-                    throw new Error(`Column ${quoteIdentifier(key)} has different types:\n${quoteIdentifier(sourceTable.name)}: ${allTypes[key]}\n${quoteIdentifier(table.name)}: ${types[key]}\nConvert ${quoteIdentifier(key)} to the same type in both tables before inserting.`);
-                }
-            }
-        }
-    }
-    let columnsAdded = {};
-    if (options.unifyColumns) {
-        columnsAdded = await unifyColumns(allTables, allTypes);
-    }
-    await queryDB(simpleTable, array
-        .map((tableToInsert) => `INSERT INTO ${quoteIdentifier(simpleTable.name)} BY NAME SELECT * FROM ${quoteIdentifier(tableToInsert.name)};`)
-        .join("\n"), mergeOptions(simpleTable, {
-        table: simpleTable.name,
-        method: "insertTables()",
-        parameters: { tables: array.map((t) => t.name) },
-    }));
-    if (options.unifyColumns) {
-        for (const table of array) {
-            const cols = columnsAdded[table.name];
-            if (cols) {
-                await removeColumnsNow(table, cols, "insertTables()");
-            }
-        }
-    }
-}

package/esm/methods/intersection.d.ts

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

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

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

package/esm/methods/intersection.js

@@ -1,19 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import queueOp from "../helpers/queueOp.js";
-export default function intersection(simpleTable, column1, column2, newColumn) {
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "intersection()",
-        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_Intersection(${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/methods/intersects.d.ts

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

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

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

package/esm/methods/intersects.js

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

package/esm/methods/join.d.ts

@@ -1,7 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function join(leftTable: SimpleTable, rightTable: SimpleTable, options?: {
-    on?: string | string[];
-    type?: "inner" | "left" | "right" | "full";
-    outputTable?: string | boolean;
-}): SimpleTable;
-//# sourceMappingURL=join.d.ts.map

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

@@ -1 +0,0 @@
-{"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,98 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import getIdenticalColumns from "../helpers/getIdenticalColumns.js";
-import queueOp from "../helpers/queueOp.js";
-import assertSameDatabase from "../helpers/assertSameDatabase.js";
-export default function join(leftTable, rightTable, options = {}) {
-    assertSameDatabase(leftTable.sdb, [rightTable], "join()");
-    options = structuredClone(options);
-    // 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"
-        ? leftTable.sdb.newTable(options.outputTable)
-        : leftTable;
-    queueOp(outputTable, {
-        kind: "source",
-        rawSQL: [quoteIdentifier(leftTable.name), quoteIdentifier(rightTable.name)],
-        method: "join()",
-        parameters: { rightTable: rightTable.name, options },
-        buildSelect: () => buildJoinSelect(leftTable, rightTable, options),
-    });
-    return outputTable;
-}
-async function buildJoinSelect(leftTable, rightTable, options) {
-    const leftTableColumns = await leftTable.getColumns();
-    const rightTableColumns = await rightTable.getColumns();
-    const identicalColumns = getIdenticalColumns(leftTableColumns, rightTableColumns);
-    let on;
-    if (typeof options.on === "string") {
-        on = [options.on];
-    }
-    else if (Array.isArray(options.on)) {
-        on = options.on;
-    }
-    else {
-        if (identicalColumns.length === 0) {
-            throw new Error(`join() cannot infer a join column because tables ${quoteIdentifier(leftTable.name)} and ${quoteIdentifier(rightTable.name)} have no columns in common. Pass { on: "column" } after ensuring that column exists in both tables.`);
-        }
-        else if (identicalColumns.length === 1) {
-            on = identicalColumns;
-        }
-        else {
-            throw new Error(`join() found ${identicalColumns.length} possible join columns shared by tables ${quoteIdentifier(leftTable.name)} and ${quoteIdentifier(rightTable.name)}: ${identicalColumns.map(quoteIdentifier).join(", ")}. Pass { on: "column" } or { on: ["column1", "column2"] } to choose.`);
-        }
-    }
-    const identicalColumnsForError = identicalColumns.filter((d) => !on.includes(d));
-    if (identicalColumnsForError.length > 0) {
-        if (identicalColumnsForError.length === 1) {
-            throw new Error(`The tables have columns with identical names (excluding ${on.map((d) => `${quoteIdentifier(d)}`).join(", ")} used for the join). Rename or remove ${identicalColumnsForError.map((d) => `${quoteIdentifier(d)}`).join(", ")} in one of the two tables before doing the join. If relevant, you can also add it to the on option.`);
-        }
-        else {
-            throw new Error(`The tables have columns with identical names (excluding ${on.map((d) => `${quoteIdentifier(d)}`).join(", ")} used for the join). Rename or remove ${identicalColumnsForError.map((d) => `${quoteIdentifier(d)}`).join(", ")} in one of the two tables before doing the join. If relevant, you can also add them to the on option.`);
-        }
-    }
-    // The right table's copies of the join columns are excluded from the
-    // SELECT directly, instead of dropping them with a rewrite after the join.
-    // The join columns come from the side that has a value for every row of
-    // the result: the left table for inner and left joins, the right table for
-    // right joins, and whichever side matched for full joins.
-    const type = options.type ?? "left";
-    const joinColumn = (d) => {
-        if (type === "right") {
-            return `${quoteIdentifier(rightTable.name)}.${quoteIdentifier(d)} AS ${quoteIdentifier(d)}`;
-        }
-        if (type === "full") {
-            return `COALESCE(${quoteIdentifier(leftTable.name)}.${quoteIdentifier(d)}, ${quoteIdentifier(rightTable.name)}.${quoteIdentifier(d)}) AS ${quoteIdentifier(d)}`;
-        }
-        return `${quoteIdentifier(leftTable.name)}.${quoteIdentifier(d)}`;
-    };
-    const selectList = [
-        ...leftTableColumns.map((d) => on.includes(d)
-            ? joinColumn(d)
-            : `${quoteIdentifier(leftTable.name)}.${quoteIdentifier(d)}`),
-        ...rightTableColumns
-            .filter((d) => !on.includes(d))
-            .map((d) => `${quoteIdentifier(rightTable.name)}.${quoteIdentifier(d)}`),
-    ].join(", ");
-    return joinQuery(leftTable.name, rightTable.name, on, type, selectList);
-}
-function joinQuery(leftTable, rightTable, on, join, selectList) {
-    let query = `SELECT ${selectList}`;
-    if (join === "inner") {
-        query += ` FROM ${quoteIdentifier(leftTable)} JOIN ${quoteIdentifier(rightTable)}`;
-    }
-    else if (join === "left") {
-        query += ` FROM ${quoteIdentifier(leftTable)} LEFT JOIN ${quoteIdentifier(rightTable)}`;
-    }
-    else if (join === "right") {
-        query += ` FROM ${quoteIdentifier(leftTable)} RIGHT JOIN ${quoteIdentifier(rightTable)}`;
-    }
-    else if (join === "full") {
-        query += ` FROM ${quoteIdentifier(leftTable)} FULL JOIN ${quoteIdentifier(rightTable)}`;
-    }
-    else {
-        throw new Error(`Unknown ${join} join.`);
-    }
-    query += ` ON (${on.map((d) => `${quoteIdentifier(leftTable)}.${quoteIdentifier(d)} = ${quoteIdentifier(rightTable)}.${quoteIdentifier(d)}`)
-        .join(" AND ")})`;
-    return query;
-}