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

package/esm/methods/cloneColumn.js

@@ -1,18 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import assertNewColumns from "../helpers/assertNewColumns.js";
-import queueOp from "../helpers/queueOp.js";
-export default function cloneColumn(simpleTable, column, newColumn) {
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "cloneColumn()",
-        parameters: { column, newColumn },
-        needsSchema: true,
-        buildSelect: (input, types) => {
-            if (!types[column]) {
-                throw new Error(`Can't find type of ${column}`);
-            }
-            assertNewColumns(types, [newColumn], "cloneColumn()");
-            return `SELECT *, ${quoteIdentifier(column)} AS ${quoteIdentifier(newColumn)} FROM ${input}`;
-        },
-    });
-}

package/esm/methods/cloneColumnWithOffset.d.ts

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

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

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

package/esm/methods/cloneColumnWithOffset.js

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

package/esm/methods/columnProportions.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"columnProportions.d.ts","sourceRoot":"","sources":["../../src/methods/columnProportions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,iBAAiB,CACvC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACd,QAqCP"}

package/esm/methods/columnProportions.js

@@ -1,28 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import assertNewColumns from "../helpers/assertNewColumns.js";
-import queueOp from "../helpers/queueOp.js";
-import stringToArray from "../helpers/stringToArray.js";
-export default function columnProportions(simpleTable, column, newColumn, options = {}) {
-    if (options.base !== undefined &&
-        (!Number.isFinite(options.base) || options.base <= 0)) {
-        throw new Error("columnProportions() options.base must be a finite number greater than 0.");
-    }
-    options = structuredClone(options);
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "columnProportions()",
-        parameters: { column, newColumn, options },
-        needsSchema: true,
-        buildSelect: (input, schema) => {
-            assertNewColumns(schema, [newColumn], "columnProportions()");
-            const by = options.by ? stringToArray(options.by) : [];
-            const partition = by.length === 0
-                ? ""
-                : `PARTITION BY ${by.map((d) => `${quoteIdentifier(d)}`).join(",")}`;
-            const proportion = `${quoteIdentifier(column)} / sum(${quoteIdentifier(column)}) OVER(${partition}) * ${options.base ?? 1}`;
-            return typeof options.decimals === "number"
-                ? `SELECT *, ROUND(${proportion}, ${options.decimals}) AS ${quoteIdentifier(newColumn)} FROM ${input}`
-                : `SELECT *, ${proportion} AS ${quoteIdentifier(newColumn)} FROM ${input}`;
-        },
-    });
-}

package/esm/methods/commonNeighbors.d.ts

@@ -1,10 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-import { type GraphId } from "../helpers/prepareGraphStarts.js";
-import { type GraphDirection } from "../helpers/prepareGraphTraversal.js";
-type CommonNeighborsOptions = {
-    direction?: GraphDirection;
-    outputTable?: string | boolean;
-};
-export default function commonNeighbors(simpleTable: SimpleTable, sourceColumn: string, targetColumn: string, nodeA: GraphId, nodeB: GraphId, options?: CommonNeighborsOptions): SimpleTable;
-export {};
-//# sourceMappingURL=commonNeighbors.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"commonNeighbors.d.ts","sourceRoot":"","sources":["../../src/methods/commonNeighbors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,OAA2B,EACzB,KAAK,OAAO,EAEb,MAAM,kCAAkC,CAAC;AAC1C,OAA8B,EAC5B,KAAK,cAAc,EAEpB,MAAM,qCAAqC,CAAC;AAI7C,KAAK,sBAAsB,GAAG;IAC5B,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,sBAA2B,GACnC,WAAW,CAwDb"}

package/esm/methods/commonNeighbors.js

@@ -1,101 +0,0 @@
-import prepareGraphStarts from "../helpers/prepareGraphStarts.js";
-import prepareGraphTraversal, { validateGraphStarts, } from "../helpers/prepareGraphTraversal.js";
-import queueGraphResult from "../helpers/queueGraphResult.js";
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-export default function commonNeighbors(simpleTable, sourceColumn, targetColumn, nodeA, nodeB, options = {}) {
-    if (typeof sourceColumn !== "string") {
-        throw new TypeError("commonNeighbors() sourceColumn must be a string.");
-    }
-    if (typeof targetColumn !== "string") {
-        throw new TypeError("commonNeighbors() targetColumn must be a string.");
-    }
-    if (options === null || typeof options !== "object" || Array.isArray(options)) {
-        throw new TypeError("commonNeighbors() options must be an object.");
-    }
-    if (options.direction !== undefined &&
-        !["outgoing", "incoming", "both"].includes(options.direction)) {
-        throw new TypeError('commonNeighbors() options.direction must be "outgoing", "incoming", or "both".');
-    }
-    if (options.outputTable !== undefined &&
-        typeof options.outputTable !== "string" &&
-        typeof options.outputTable !== "boolean") {
-        throw new TypeError("commonNeighbors() options.outputTable must be a string or boolean.");
-    }
-    const nodes = prepareNodes(nodeA, nodeB);
-    options = structuredClone(options);
-    const direction = options.direction ?? "outgoing";
-    const parameters = { sourceColumn, targetColumn, nodeA, nodeB, options };
-    return queueGraphResult(simpleTable, {
-        method: "commonNeighbors()",
-        parameters,
-        outputTable: options.outputTable,
-        values: (schema) => {
-            validateNodes(schema, sourceColumn, targetColumn, nodes);
-            return nodes.values;
-        },
-        buildSelect: (input, schema) => commonNeighborsSelect(input, schema, sourceColumn, targetColumn, nodes, direction),
-        outputSchema: (schema) => ({
-            node: validateNodes(schema, sourceColumn, targetColumn, nodes).idType,
-        }),
-    });
-}
-function prepareNodes(nodeA, nodeB) {
-    if (Array.isArray(nodeA)) {
-        throw new TypeError("commonNeighbors() nodeA must be one node ID.");
-    }
-    if (Array.isArray(nodeB)) {
-        throw new TypeError("commonNeighbors() nodeB must be one node ID.");
-    }
-    const first = prepareGraphStarts(nodeA, "commonNeighbors()", "nodeA", true);
-    const second = prepareGraphStarts(nodeB, "commonNeighbors()", "nodeB", true);
-    if (first.family !== second.family) {
-        throw new TypeError("commonNeighbors() nodeA and nodeB must both be string IDs or both be numeric IDs.");
-    }
-    if (first.values[0] === second.values[0]) {
-        throw new TypeError("commonNeighbors() nodeA and nodeB must be different.");
-    }
-    return {
-        family: first.family,
-        numericValues: [...first.numericValues, ...second.numericValues],
-        values: [first.values[0], second.values[0]],
-    };
-}
-function validateNodes(schema, source, target, nodes) {
-    return validateGraphStarts(schema, source, target, nodes, "commonNeighbors()", "nodeA and nodeB");
-}
-function commonNeighborsSelect(input, schema, source, target, nodes, direction) {
-    const prepared = prepareGraphTraversal(input, schema, source, target, nodes, "commonNeighbors()", "nodeA and nodeB");
-    const relations = prepared.relationNames([
-        "graph_requested_nodes",
-        "graph_edges",
-        "graph_neighbor_memberships",
-        "graph_common_neighbors",
-    ]);
-    const requested = relations.graph_requested_nodes;
-    const edges = relations.graph_edges;
-    const memberships = relations.graph_neighbor_memberships;
-    const common = relations.graph_common_neighbors;
-    const q = quoteIdentifier;
-    return `WITH ${requested}(${q("node")}) AS (
-      VALUES ${prepared.startValues}
-    ), ${edges} AS (
-      ${prepared.edges(direction)}
-    ), ${memberships} AS (
-      SELECT ${q("requested")}.${q("node")} AS ${q("requested_node")},
-        ${q("edges")}.${q("__from_key")} AS ${q("__requested_key")},
-        ${q("edges")}.${q("__to")} AS ${q("node")},
-        ${q("edges")}.${q("__to_key")} AS ${q("__node_key")}
-      FROM ${edges} AS ${q("edges")}
-      INNER JOIN ${requested} AS ${q("requested")}
-        ON ${q("edges")}.${q("__from_key")} =
-          ${prepared.key(`${q("requested")}.${q("node")}`)}
-    ), ${common} AS (
-      SELECT MIN(${q("node")}) AS ${q("node")}, ${q("__node_key")}
-      FROM ${memberships}
-      GROUP BY ${q("__node_key")}
-      HAVING COUNT(DISTINCT ${q("__requested_key")}) = 2
-    )
-    SELECT ${q("node")}
-    FROM ${common}
-    ORDER BY ${q("__node_key")}`;
-}

package/esm/methods/concatenate.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"concatenate.d.ts","sourceRoot":"","sources":["../../src/methods/concatenate.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,MAAM,CAAC;CACf,QA0BP"}

package/esm/methods/concatenate.js

@@ -1,25 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import assertNewColumns from "../helpers/assertNewColumns.js";
-import queueOp from "../helpers/queueOp.js";
-export default function concatenate(simpleTable, columns, newColumn, options = {}) {
-    columns = [...columns];
-    options = structuredClone(options);
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "concatenate()",
-        parameters: { columns, newColumn, options },
-        needsSchema: true,
-        values: typeof options.separator === "string"
-            ? [options.separator]
-            : undefined,
-        buildSelect: (input, types) => {
-            assertNewColumns(types, [newColumn], "concatenate()");
-            const expression = typeof options.separator === "string"
-                ? `CONCAT_WS(?, ${columns
-                    .map((d) => `${quoteIdentifier(d)}`)
-                    .join(", ")})`
-                : `CONCAT(${columns.map((d) => `${quoteIdentifier(d)}`).join(", ")})`;
-            return `SELECT *, CAST(${expression} AS VARCHAR) AS ${quoteIdentifier(newColumn)} FROM ${input}`;
-        },
-    });
-}

package/esm/methods/connectedComponents.d.ts

@@ -1,9 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-import { type GraphTemporalOptions } from "../helpers/prepareGraphTemporalSql.js";
-type ConnectedComponentsOptions = GraphTemporalOptions & {
-    mode?: "weak" | "strong";
-    outputTable?: string | boolean;
-};
-export default function connectedComponents(simpleTable: SimpleTable, sourceColumn: string, targetColumn: string, options?: ConnectedComponentsOptions): SimpleTable;
-export {};
-//# sourceMappingURL=connectedComponents.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"connectedComponents.d.ts","sourceRoot":"","sources":["../../src/methods/connectedComponents.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,OAAgC,EAC9B,KAAK,oBAAoB,EAG1B,MAAM,uCAAuC,CAAC;AAM/C,KAAK,0BAA0B,GAAG,oBAAoB,GAAG;IACvD,IAAI,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,0BAA+B,GACvC,WAAW,CAqFb"}

package/esm/methods/connectedComponents.js

@@ -1,147 +0,0 @@
-import buildChronologicalGraphComponentsSql from "../helpers/buildChronologicalGraphComponentsSql.js";
-import buildWeakGraphComponentsSql from "../helpers/buildWeakGraphComponentsSql.js";
-import getGraphEndpointColumns from "../helpers/getGraphEndpointColumns.js";
-import prepareGraphTemporalSql, { prepareGraphTemporalOptions, } from "../helpers/prepareGraphTemporalSql.js";
-import { prepareGraphSql } from "../helpers/prepareGraphTraversal.js";
-import queueGraphResult from "../helpers/queueGraphResult.js";
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import validateGraphTemporalEvents from "../helpers/validateGraphTemporalEvents.js";
-export default function connectedComponents(simpleTable, sourceColumn, targetColumn, options = {}) {
-    if (typeof sourceColumn !== "string") {
-        throw new TypeError("connectedComponents() sourceColumn must be a string.");
-    }
-    if (typeof targetColumn !== "string") {
-        throw new TypeError("connectedComponents() targetColumn must be a string.");
-    }
-    if (options === null || typeof options !== "object" || Array.isArray(options)) {
-        throw new TypeError("connectedComponents() options must be an object.");
-    }
-    if (options.mode !== undefined &&
-        !["weak", "strong"].includes(options.mode)) {
-        throw new TypeError('connectedComponents() options.mode must be "weak" or "strong".');
-    }
-    if (options.outputTable !== undefined &&
-        typeof options.outputTable !== "string" &&
-        typeof options.outputTable !== "boolean") {
-        throw new TypeError("connectedComponents() options.outputTable must be a string or boolean.");
-    }
-    const temporalOptions = prepareGraphTemporalOptions(options, undefined, "connectedComponents()");
-    if (temporalOptions !== undefined && options.mode !== "strong") {
-        throw new TypeError('connectedComponents() chronological options require options.mode to be explicitly set to "strong".');
-    }
-    options = structuredClone(options);
-    const mode = options.mode ?? "weak";
-    const parameters = { sourceColumn, targetColumn, options };
-    return queueGraphResult(simpleTable, {
-        method: "connectedComponents()",
-        parameters,
-        outputTable: options.outputTable,
-        preflight: temporalOptions === undefined
-            ? undefined
-            : (input) => validateGraphTemporalEvents(input, temporalOptions, "connectedComponents()", parameters),
-        values: (schema) => {
-            const temporal = validateInputs(schema, sourceColumn, targetColumn, temporalOptions).temporal;
-            return temporal === undefined ? [] : [temporal.gapParameter];
-        },
-        buildSelect: (input, schema) => connectedComponentsSelect(input, schema, sourceColumn, targetColumn, mode, temporalOptions),
-        outputSchema: (schema) => ({
-            componentId: "BIGINT",
-            node: validateInputs(schema, sourceColumn, targetColumn, temporalOptions).endpoints.idType,
-        }),
-    });
-}
-function validateEndpoints(schema, source, target) {
-    return getGraphEndpointColumns(schema, source, target, "connectedComponents()");
-}
-function validateInputs(schema, source, target, temporalOptions) {
-    const endpoints = validateEndpoints(schema, source, target);
-    const temporal = temporalOptions === undefined
-        ? undefined
-        : prepareGraphTemporalSql(schema, temporalOptions, "connectedComponents()");
-    return { endpoints, temporal };
-}
-function connectedComponentsSelect(input, schema, source, target, mode, temporalOptions) {
-    const prepared = prepareGraphSql(input, schema, source, target, "connectedComponents()");
-    if (temporalOptions !== undefined) {
-        return buildChronologicalGraphComponentsSql(prepared, prepareGraphTemporalSql(schema, temporalOptions, "connectedComponents()"));
-    }
-    const relationNames = mode === "weak"
-        ? [
-            "graph_edges",
-            "graph_nodes",
-            "graph_component_labels",
-            "graph_component_roots",
-        ]
-        : [
-            "graph_edges",
-            "graph_nodes",
-            "graph_reachable",
-            "graph_component_members",
-            "graph_component_roots",
-        ];
-    const relations = prepared.relationNames(relationNames);
-    const edges = relations.graph_edges;
-    const nodes = relations.graph_nodes;
-    const roots = relations.graph_component_roots;
-    const q = quoteIdentifier;
-    const common = `${edges} AS (
-      ${prepared.edges(mode === "weak" ? "both" : "outgoing")}
-    ), ${nodes} AS (
-      SELECT ${q("__from")} AS ${q("node")},
-        ${q("__from_key")} AS ${q("__key")}
-      FROM ${edges}
-      UNION
-      SELECT ${q("__to")} AS ${q("node")},
-        ${q("__to_key")} AS ${q("__key")}
-      FROM ${edges}
-    )`;
-    if (mode === "weak") {
-        const labels = relations.graph_component_labels;
-        return `WITH RECURSIVE ${common}, ${buildWeakGraphComponentsSql(edges, nodes, labels, roots)}
-    SELECT ${q("roots")}.${q("componentId")}, ${q("labels")}.${q("node")}
-    FROM ${labels} AS ${q("labels")}
-    INNER JOIN ${roots} AS ${q("roots")}
-      ON ${q("labels")}.${q("__root_key")} =
-        ${q("roots")}.${q("__root_key")}
-    ORDER BY ${q("labels")}.${q("__node_key")}`;
-    }
-    const reachable = relations.graph_reachable;
-    const members = relations.graph_component_members;
-    return `WITH RECURSIVE ${common}, ${reachable}(
-      ${q("__start_key")}, ${q("__node_key")}
-    ) AS (
-      SELECT ${q("__key")}, ${q("__key")} FROM ${nodes}
-      UNION
-      SELECT ${q("reached")}.${q("__start_key")},
-        ${q("edges")}.${q("__to_key")}
-      FROM ${reachable} AS ${q("reached")}
-      INNER JOIN ${edges} AS ${q("edges")}
-        ON ${q("reached")}.${q("__node_key")} =
-          ${q("edges")}.${q("__from_key")}
-    ), ${members} AS (
-      SELECT ${q("nodes")}.${q("node")}, ${q("nodes")}.${q("__key")},
-        MIN(${q("forward")}.${q("__start_key")}) AS ${q("__root_key")}
-      FROM ${nodes} AS ${q("nodes")}
-      INNER JOIN ${reachable} AS ${q("forward")}
-        ON ${q("nodes")}.${q("__key")} =
-          ${q("forward")}.${q("__node_key")}
-      INNER JOIN ${reachable} AS ${q("reverse")}
-        ON ${q("forward")}.${q("__start_key")} =
-          ${q("reverse")}.${q("__node_key")}
-        AND ${q("nodes")}.${q("__key")} =
-          ${q("reverse")}.${q("__start_key")}
-      GROUP BY ${q("nodes")}.${q("node")}, ${q("nodes")}.${q("__key")}
-    ), ${roots} AS (
-      SELECT ${q("__root_key")},
-        CAST(row_number() OVER (ORDER BY ${q("__root_key")}) - 1 AS BIGINT)
-          AS ${q("componentId")}
-      FROM (SELECT DISTINCT ${q("__root_key")} FROM ${members})
-        AS ${q("distinct_roots")}
-    )
-    SELECT ${q("roots")}.${q("componentId")}, ${q("members")}.${q("node")}
-    FROM ${members} AS ${q("members")}
-    INNER JOIN ${roots} AS ${q("roots")}
-      ON ${q("members")}.${q("__root_key")} =
-        ${q("roots")}.${q("__root_key")}
-    ORDER BY ${q("members")}.${q("__key")}`;
-}

package/esm/methods/convert.d.ts

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

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

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

package/esm/methods/convert.js

@@ -1,117 +0,0 @@
-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,
-        needsSpatial: Object.values(types).some((type) => type.toLowerCase().startsWith("geometry")),
-        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 (options.strict === false && expectedType.startsWith("GEOMETRY")) {
-                // DuckDB's geometry parser can throw even inside TRY_CAST.
-                query += ` TRY(CAST(${quoteIdentifier(column)} AS ${expectedType})) AS ${quoteIdentifier(column)},`;
-            }
-            else if (stringToNumber) {
-                // Thousand separators would make the cast fail.
-                query += ` ${cast}(REPLACE(${quoteIdentifier(column)}, ',', '') AS ${parseType(columnsTypes[indexOf])}) AS ${quoteIdentifier(column)},`;
-            }
-            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/methods/correlations.d.ts

@@ -1,9 +0,0 @@
-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/methods/correlations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"correlations.d.ts","sourceRoot":"","sources":["../../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"}