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

package/esm/methods/selectRows.js

@@ -1,34 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import queueOp from "../helpers/queueOp.js";
-import resolveOutputTable from "../helpers/resolveOutputTable.js";
-export default function selectRows(simpleTable, count, options = {}) {
-    options = { ...options };
-    options.outputTable = resolveOutputTable(simpleTable, options.outputTable);
-    const limitAndOffset = `LIMIT ${count}${typeof options.offset === "number" ? ` OFFSET ${options.offset}` : ""}`;
-    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: "source",
-            method: "selectRows()",
-            parameters: { count, options },
-            // The output table reads simpleTable by name rather than through its
-            // own (nonexistent) chain, so simpleTable's pending work must close
-            // and execute before this SELECT runs, as it would at this call
-            // position.
-            rawSQL: [`${quoteIdentifier(simpleTable.name)}`],
-            buildSelect: () => `SELECT * FROM ${quoteIdentifier(simpleTable.name)} ${limitAndOffset}`,
-        });
-        return outputTable;
-    }
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "selectRows()",
-        parameters: { count, options },
-        needsSchema: false,
-        preservesSchema: true,
-        buildSelect: (input) => `SELECT * FROM ${input} ${limitAndOffset}`,
-    });
-    return simpleTable;
-}

package/esm/methods/selectTables.d.ts

@@ -1,4 +0,0 @@
-import SimpleTable from "../class/SimpleTable.js";
-import type SimpleDB from "../class/SimpleDB.js";
-export default function selectTables(simpleDB: SimpleDB, tables: SimpleTable | string | (SimpleTable | string)[]): Promise<void>;
-//# sourceMappingURL=selectTables.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"selectTables.d.ts","sourceRoot":"","sources":["../../src/methods/selectTables.ts"],"names":[],"mappings":"AAIA,OAAO,WAAW,MAAM,yBAAyB,CAAC;AAClD,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AAKjD,wBAA8B,YAAY,CACxC,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,WAAW,GAAG,MAAM,GAAG,CAAC,WAAW,GAAG,MAAM,CAAC,EAAE,iBAqDxD"}

package/esm/methods/selectTables.js

@@ -1,31 +0,0 @@
-import { assertCacheTableMutation } from "../helpers/cacheTableDependencies.js";
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import mergeOptions from "../helpers/mergeOptions.js";
-import queryDB from "../helpers/queryDB.js";
-import SimpleTable from "../class/SimpleTable.js";
-import { retainRegisteredTables } from "../helpers/tableRegistry.js";
-import assertSameDatabase from "../helpers/assertSameDatabase.js";
-import formatMissingTables from "../helpers/formatMissingTables.js";
-export default async function selectTables(simpleDB, tables) {
-    const selected = Array.isArray(tables) ? tables : [tables];
-    assertSameDatabase(simpleDB, selected.filter((table) => table instanceof SimpleTable), "selectTables()");
-    const tablesToBeSelected = selected.map((t) => t instanceof SimpleTable ? t.name : t);
-    for (const table of simpleDB.getTables()) {
-        if (!tablesToBeSelected.includes(table.name)) {
-            assertCacheTableMutation(table);
-        }
-    }
-    const existingTables = await simpleDB.getTableNames();
-    const missingTables = tablesToBeSelected.filter((table) => !existingTables.includes(table));
-    if (missingTables.length > 0) {
-        throw new Error(formatMissingTables("selectTables()", missingTables, existingTables));
-    }
-    const tablesToBeRemoved = simpleDB.getTables().filter((t) => !tablesToBeSelected.includes(t.name));
-    await queryDB(simpleDB, tablesToBeRemoved.map((d) => `DROP TABLE ${quoteIdentifier(d instanceof SimpleTable ? d.name : d)};`).join("\n"), mergeOptions(simpleDB, {
-        table: null,
-        method: "removeTable()",
-        parameters: {},
-    }));
-    const tablesNamesToBeRemoved = tablesToBeRemoved.map((t) => t instanceof SimpleTable ? t.name : t);
-    retainRegisteredTables(simpleDB, (table) => !tablesNamesToBeRemoved.includes(table.name));
-}

package/esm/methods/setTypes.d.ts

@@ -1,5 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function setTypes(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}')`;
-}): void;
-//# sourceMappingURL=setTypes.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"setTypes.d.ts","sourceRoot":"","sources":["../../src/methods/setTypes.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,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,QAkCF"}

package/esm/methods/setTypes.js

@@ -1,30 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import ensureSpatial from "../helpers/ensureSpatial.js";
-import mergeOptions from "../helpers/mergeOptions.js";
-import parseType from "../helpers/parseTypes.js";
-import queryDB from "../helpers/queryDB.js";
-import queueOp from "../helpers/queueOp.js";
-export default function setTypes(simpleTable, types) {
-    // Creating a table from scratch (possibly with the spatial extension) is
-    // multi-statement by nature: it executes as a barrier.
-    types = structuredClone(types);
-    queueOp(simpleTable, {
-        kind: "barrier",
-        method: "setTypes()",
-        parameters: { types },
-        execute: async () => {
-            if (Object.values(types)
-                .map((d) => d.toLowerCase())
-                .some((d) => d.startsWith("geometry"))) {
-                await ensureSpatial(simpleTable);
-            }
-            await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(simpleTable.name)} (${Object.keys(types)
-                .map((d) => `${quoteIdentifier(d)} ${parseType(types[d])}`)
-                .join(", ")});`, mergeOptions(simpleTable, {
-                table: simpleTable.name,
-                method: "setTypes()",
-                parameters: { types },
-            }));
-        },
-    });
-}

package/esm/methods/shortestPath.d.ts

@@ -1,14 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-import type { GraphId } from "../helpers/prepareGraphStarts.js";
-import { type GraphTemporalOptions } from "../helpers/prepareGraphTemporalSql.js";
-import type { GraphDirection } from "../helpers/prepareGraphTraversal.js";
-type ShortestPathOptions = GraphTemporalOptions & {
-    direction?: GraphDirection;
-    outputTable?: string | boolean;
-    weight?: string;
-    elapsedTime?: boolean;
-    minimize?: "steps" | "weight" | "elapsedTime";
-};
-export default function shortestPath(simpleTable: SimpleTable, sourceColumn: string, targetColumn: string, edgeId: string, start: GraphId, end: GraphId, options?: ShortestPathOptions): SimpleTable;
-export {};
-//# sourceMappingURL=shortestPath.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"shortestPath.d.ts","sourceRoot":"","sources":["../../src/methods/shortestPath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAShE,OAAgC,EAC9B,KAAK,oBAAoB,EAG1B,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAK1E,KAAK,mBAAmB,GAAG,oBAAoB,GAAG;IAChD,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,aAAa,CAAC;CAC/C,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,OAAO,EACZ,OAAO,GAAE,mBAAwB,GAChC,WAAW,CAyHb"}

package/esm/methods/shortestPath.js

@@ -1,458 +0,0 @@
-import buildGraphTemporalCostStateSql from "../helpers/buildGraphTemporalCostStateSql.js";
-import prepareGraphMetricOptions from "../helpers/prepareGraphMetricOptions.js";
-import { prepareGraphRouteEndpoints, prepareGraphRouteSql, validateGraphRouteInputs, } from "../helpers/prepareGraphRouteSql.js";
-import graphRouteResultSchema from "../helpers/graphRouteResultSchema.js";
-import graphRouteResultSelect from "../helpers/graphRouteResultSelect.js";
-import prepareGraphTemporalSql, { prepareGraphTemporalOptions, } from "../helpers/prepareGraphTemporalSql.js";
-import queueGraphResult from "../helpers/queueGraphResult.js";
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import validateGraphTemporalEvents from "../helpers/validateGraphTemporalEvents.js";
-export default function shortestPath(simpleTable, sourceColumn, targetColumn, edgeId, start, end, options = {}) {
-    if (typeof sourceColumn !== "string") {
-        throw new TypeError("shortestPath() sourceColumn must be a string.");
-    }
-    if (typeof targetColumn !== "string") {
-        throw new TypeError("shortestPath() targetColumn must be a string.");
-    }
-    if (typeof edgeId !== "string") {
-        throw new TypeError("shortestPath() edgeId must be a string.");
-    }
-    if (options === null || typeof options !== "object" || Array.isArray(options)) {
-        throw new TypeError("shortestPath() options must be an object.");
-    }
-    if (options.direction !== undefined &&
-        !["outgoing", "incoming", "both"].includes(options.direction)) {
-        throw new TypeError('shortestPath() options.direction must be "outgoing", "incoming", or "both".');
-    }
-    if (options.weight !== undefined && typeof options.weight !== "string") {
-        throw new TypeError("shortestPath() options.weight must be a string.");
-    }
-    if (options.outputTable !== undefined &&
-        typeof options.outputTable !== "string" &&
-        typeof options.outputTable !== "boolean") {
-        throw new TypeError("shortestPath() options.outputTable must be a string or boolean.");
-    }
-    const metrics = prepareGraphMetricOptions(options, "shortestPath()", true);
-    const endpoints = prepareGraphRouteEndpoints(start, end, "shortestPath()");
-    const direction = options.direction ?? "outgoing";
-    const temporalOptions = prepareGraphTemporalOptions(options, direction, "shortestPath()");
-    options = structuredClone(options);
-    const parameters = {
-        sourceColumn,
-        targetColumn,
-        edgeId,
-        start,
-        end,
-        options,
-    };
-    return queueGraphResult(simpleTable, {
-        method: "shortestPath()",
-        parameters,
-        outputTable: options.outputTable,
-        preflight: temporalOptions === undefined
-            ? undefined
-            : (input) => validateGraphTemporalEvents(input, temporalOptions, "shortestPath()", parameters),
-        values: (schema) => {
-            validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "shortestPath()", options.weight !== undefined);
-            const temporal = temporalOptions === undefined
-                ? undefined
-                : prepareGraphTemporalSql(schema, temporalOptions, "shortestPath()");
-            return temporal === undefined
-                ? endpoints.values.values
-                : [temporal.gapParameter, ...endpoints.values.values];
-        },
-        buildSelect: (input, schema) => shortestPathSelect(input, schema, sourceColumn, targetColumn, edgeId, endpoints, direction, options.weight, temporalOptions, metrics),
-        outputSchema: (schema) => {
-            const validated = validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "shortestPath()", options.weight !== undefined);
-            if (temporalOptions !== undefined) {
-                prepareGraphTemporalSql(schema, temporalOptions, "shortestPath()");
-            }
-            return graphRouteResultSchema(schema, validated.distanceType, "shortestPath()", metrics.elapsedTime, options.weight !== undefined);
-        },
-    });
-}
-function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoints, direction, weight, temporalOptions, metrics) {
-    const route = prepareGraphRouteSql(input, schema, source, target, edgeId, routeEndpoints, weight, "shortestPath()", weight !== undefined);
-    const prepared = route.traversal;
-    if (temporalOptions !== undefined) {
-        const temporal = prepareGraphTemporalSql(schema, temporalOptions, "shortestPath()");
-        return temporalShortestPathSelect(route, direction, temporal, metrics, weight !== undefined);
-    }
-    const distanceType = route.distanceType;
-    // Exact shortest routes have optimal prefixes. Floating addition can erase
-    // a prefix-cost difference later, so retain all simple prefixes up to the
-    // best complete cost before selecting the full-route ties.
-    const floating = metrics.minimize === "weight" &&
-        (route.weightType === "FLOAT" || route.weightType === "DOUBLE");
-    const metricType = metrics.minimize === "steps" ? "BIGINT" : distanceType;
-    const relations = prepared.relationNames([
-        "graph_route_endpoints",
-        "graph_edges",
-        "graph_nodes",
-        "graph_to_end",
-        "graph_distances",
-        "graph_best_total",
-        "graph_routes",
-        "graph_shortest_routes",
-        "graph_ranked_routes",
-    ]);
-    const endpointRelation = relations.graph_route_endpoints;
-    const edgesRelation = relations.graph_edges;
-    const nodesRelation = relations.graph_nodes;
-    const toEndRelation = relations.graph_to_end;
-    const distancesRelation = relations.graph_distances;
-    const bestTotalRelation = relations.graph_best_total;
-    const routesRelation = relations.graph_routes;
-    const shortestRelation = relations.graph_shortest_routes;
-    const rankedRelation = relations.graph_ranked_routes;
-    const q = quoteIdentifier;
-    const edgeFromKey = `${q("edges")}.${q("__from_key")}`;
-    const edgeToKey = `${q("edges")}.${q("__to_key")}`;
-    const edgeTo = `${q("edges")}.${q("__to")}`;
-    const edgeCost = `${q("edges")}.${q("__weight")}`;
-    const edgeMetric = metrics.minimize === "steps"
-        ? "CAST(1 AS BIGINT)"
-        : edgeCost;
-    const routeDistance = `${q("routes")}.${q("distance")}`;
-    const candidateDistance = `CAST(${routeDistance} + ${edgeCost} AS ${distanceType})`;
-    const routeMetric = metrics.minimize === "steps"
-        ? `len(${q("routes")}.${q("steps")})`
-        : routeDistance;
-    const candidateMetric = metrics.minimize === "steps"
-        ? `${routeMetric} + 1`
-        : candidateDistance;
-    return `WITH RECURSIVE ${endpointRelation}(
-      ${q("start")}, ${q("end")}, ${q("__start_key")}, ${q("__end_key")}
-    ) AS (
-      SELECT ${q("start")}, ${q("end")},
-        ${prepared.key(q("start"))}, ${prepared.key(q("end"))}
-      FROM (SELECT ${route.endpointValue} AS ${q("start")},
-        ${route.endpointValue} AS ${q("end")}) AS ${q("values")}
-    ), ${edgesRelation} AS (
-      ${prepared.edges(direction, [
-        `${route.typedEdgeId} AS ${q("__edge_id")}`,
-        `${route.edgeKey} AS ${q("__edge_key")}`,
-        `${route.edgeWeight} AS ${q("__weight")}`,
-    ])}
-    ), ${nodesRelation} AS (
-      SELECT ${q("__from_key")} AS ${q("__key")} FROM ${edgesRelation}
-      UNION
-      SELECT ${q("__to_key")} AS ${q("__key")} FROM ${edgesRelation}
-    ), ${toEndRelation}(${q("__key")}) AS (
-      SELECT ${q("__end_key")}
-      FROM ${endpointRelation}
-      INNER JOIN ${nodesRelation}
-        ON ${q("__end_key")} = ${q("__key")}
-      UNION
-      SELECT ${edgeFromKey}
-      FROM ${toEndRelation} AS ${q("reached")}
-      INNER JOIN ${edgesRelation} AS ${q("edges")}
-        ON ${q("reached")}.${q("__key")} = ${edgeToKey}
-    ), ${distancesRelation}(
-      ${q("node")}, ${q("__node_key")}, ${q("distance")}
-    ) USING KEY(${q("__node_key")}) AS (
-      SELECT ${q("start")}, ${q("__start_key")},
-        CAST(0 AS ${metricType})
-      FROM ${endpointRelation}
-      INNER JOIN ${toEndRelation}
-        ON ${q("__start_key")} = ${q("__key")}
-      UNION
-      SELECT ${edgeTo}, ${edgeToKey},
-        MIN(CAST(${q("reached")}.${q("distance")} + ${edgeMetric} AS ${metricType}))
-      FROM ${distancesRelation} AS ${q("reached")}
-      INNER JOIN ${edgesRelation} AS ${q("edges")}
-        ON ${q("reached")}.${q("__node_key")} = ${edgeFromKey}
-      INNER JOIN ${toEndRelation} AS ${q("can_reach_end")}
-        ON ${edgeToKey} = ${q("can_reach_end")}.${q("__key")}
-      LEFT JOIN recurring.${distancesRelation} AS ${q("best")}
-        ON ${edgeToKey} = ${q("best")}.${q("__node_key")}
-      GROUP BY ${edgeTo}, ${edgeToKey}, ${q("best")}.${q("distance")}
-      HAVING ${q("best")}.${q("distance")} IS NULL
-        OR MIN(CAST(${q("reached")}.${q("distance")} + ${edgeMetric} AS ${metricType})) < ${q("best")}.${q("distance")}
-    ), ${bestTotalRelation} AS (
-      SELECT ${q("distances")}.${q("distance")}
-      FROM ${distancesRelation} AS ${q("distances")}
-      INNER JOIN ${endpointRelation}
-        ON ${q("distances")}.${q("__node_key")} = ${q("__end_key")}
-    ), ${routesRelation}(
-      ${q("node")}, ${q("__node_key")}, ${q("__visited")},
-      ${q("__edge_keys")}, ${q("steps")}, ${q("distance")}
-    ) AS (
-      SELECT ${q("start")}, ${q("__start_key")},
-        [${q("__start_key")}], CAST([] AS ${route.keyType}[]),
-        CAST([] AS ${route.stepType}[]), CAST(0 AS ${distanceType})
-      FROM ${endpointRelation}
-      INNER JOIN ${bestTotalRelation} ON TRUE
-      UNION ALL
-      SELECT ${edgeTo}, ${edgeToKey},
-        list_append(${q("routes")}.${q("__visited")}, ${edgeToKey}),
-        list_append(${q("routes")}.${q("__edge_keys")}, ${q("edges")}.${q("__edge_key")}),
-        list_append(${q("routes")}.${q("steps")}, struct_pack(
-          ${q("edgeId")} := ${q("edges")}.${q("__edge_id")},
-          ${q("source")} := ${q("edges")}.${q("__from")},
-          ${q("target")} := ${edgeTo},
-          ${q("weight")} := ${edgeCost},
-          ${q("distance")} := ${candidateDistance}
-        )), ${candidateDistance}
-      FROM ${routesRelation} AS ${q("routes")}
-      INNER JOIN ${edgesRelation} AS ${q("edges")}
-        ON ${q("routes")}.${q("__node_key")} = ${edgeFromKey}
-      INNER JOIN ${toEndRelation} AS ${q("can_reach_end")}
-        ON ${edgeToKey} = ${q("can_reach_end")}.${q("__key")}
-      INNER JOIN ${bestTotalRelation} AS ${q("best_total")}
-        ON TRUE
-      ${floating ? "" : `INNER JOIN ${distancesRelation} AS ${q("best_prefix")}
-        ON ${edgeToKey} = ${q("best_prefix")}.${q("__node_key")}`}
-      CROSS JOIN ${endpointRelation}
-      WHERE ${q("routes")}.${q("__node_key")} <> ${q("__end_key")}
-        AND NOT list_contains(${q("routes")}.${q("__visited")}, ${edgeToKey})
-        AND ${floating
-        ? `${candidateMetric} <= ${q("best_total")}.${q("distance")}`
-        : `${candidateMetric} = ${q("best_prefix")}.${q("distance")}`}
-    ), ${shortestRelation} AS (
-      SELECT ${q("__edge_keys")}, ${q("steps")}
-      FROM ${routesRelation} AS ${q("routes")}
-      CROSS JOIN ${endpointRelation}
-      CROSS JOIN ${bestTotalRelation} AS ${q("best_total")}
-      WHERE ${q("__node_key")} = ${q("__end_key")}
-        AND ${routeMetric} = ${q("best_total")}.${q("distance")}
-    ), ${rankedRelation} AS (
-      SELECT CAST(row_number() OVER (ORDER BY ${q("__edge_keys")}) - 1 AS BIGINT) AS ${q("pathId")},
-        ${q("steps")}
-      FROM ${shortestRelation}
-    )
-    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn, false, false, weight !== undefined)}`;
-}
-function temporalShortestPathSelect(route, direction, temporal, metrics, includeTotal) {
-    const prepared = route.traversal;
-    const q = quoteIdentifier;
-    const startsSelect = `SELECT ${q("start")},
-        ${prepared.key(q("start"))} AS ${q("__key")}
-      FROM (SELECT ${route.endpointValue} AS ${q("start")}) AS ${q("values")}`;
-    // Non-negative weights and no maximum gap let cycles be removed from walks.
-    // Their optimum bounds simple routes; retain separate histories for all ties.
-    const costs = metrics.minimize === "elapsedTime"
-        ? buildElapsedShortestPathCostSql(route, startsSelect, direction, temporal)
-        : buildGraphTemporalCostStateSql(prepared, startsSelect, direction, temporal, route.distanceType, route.edgeWeight, [
-            `${route.typedEdgeId} AS ${q("__edge_id")}`,
-            `${route.edgeKey} AS ${q("__edge_key")}`,
-        ], metrics.minimize === "steps" ? "steps" : "weight");
-    const relations = prepared.relationNames([
-        "graph_route_endpoints",
-        "graph_nodes",
-        "graph_to_end",
-        "graph_best_total",
-        "graph_routes",
-        "graph_shortest_routes",
-        "graph_ranked_routes",
-    ]);
-    const endpointRelation = relations.graph_route_endpoints;
-    const nodesRelation = relations.graph_nodes;
-    const toEndRelation = relations.graph_to_end;
-    const bestTotalRelation = relations.graph_best_total;
-    const routesRelation = relations.graph_routes;
-    const shortestRelation = relations.graph_shortest_routes;
-    const rankedRelation = relations.graph_ranked_routes;
-    const edgesRelation = costs.edgesRelation;
-    const edgeFromKey = `${q("edges")}.${q("__from_key")}`;
-    const edgeToKey = `${q("edges")}.${q("__to_key")}`;
-    const edgeTo = `${q("edges")}.${q("__to")}`;
-    const edgeCost = `${q("edges")}.${q("__weight")}`;
-    const edgeKey = `${q("edges")}.${q("__edge_key")}`;
-    const routeDistance = `${q("routes")}.${q("distance")}`;
-    const candidateDistance = `CAST(${routeDistance} + ${edgeCost} AS ${route.distanceType})`;
-    const gap = `${q("settings")}.${q("__gap")}`;
-    const firstAnchor = temporal.journeyAnchor("edges", direction);
-    const routeAnchor = `${q("routes")}.${q("__journey_anchor")}`;
-    const firstElapsed = temporal.journeyElapsed("edges", firstAnchor, direction);
-    const candidateElapsed = temporal.journeyElapsed("edges", routeAnchor, direction);
-    const firstMetric = metrics.minimize === "steps"
-        ? "1"
-        : metrics.minimize === "elapsedTime"
-            ? firstElapsed
-            : edgeCost;
-    const routeMetric = metrics.minimize === "steps"
-        ? `len(${q("routes")}.${q("steps")})`
-        : metrics.minimize === "elapsedTime"
-            ? `${q("routes")}.${q("__elapsed")}`
-            : routeDistance;
-    const candidateMetric = metrics.minimize === "steps"
-        ? `${routeMetric} + 1`
-        : metrics.minimize === "elapsedTime"
-            ? candidateElapsed
-            : candidateDistance;
-    const step = (distance, elapsed) => `struct_pack(
-          ${q("edgeId")} := ${q("edges")}.${q("__edge_id")},
-          ${q("source")} := ${q("edges")}.${q("__from")},
-          ${q("target")} := ${edgeTo},
-          ${q("weight")} := ${edgeCost},
-          ${q("distance")} := ${distance}${metrics.elapsedTime
-        ? `, ${q("elapsedTimeMs")} := ${temporal.elapsedMilliseconds(elapsed)}`
-        : ""}
-        )`;
-    return `${costs.withClause}, ${endpointRelation}(
-      ${q("start")}, ${q("end")}, ${q("__start_key")}, ${q("__end_key")}
-    ) AS (
-      SELECT ${q("starts")}.${q("start")}, ${q("values")}.${q("end")},
-        ${q("starts")}.${q("__key")},
-        ${prepared.key(`${q("values")}.${q("end")}`)}
-      FROM ${costs.startsRelation} AS ${q("starts")}
-      CROSS JOIN (SELECT ${route.endpointValue} AS ${q("end")}) AS ${q("values")}
-    ), ${nodesRelation} AS (
-      SELECT ${q("__from_key")} AS ${q("__key")} FROM ${edgesRelation}
-      UNION
-      SELECT ${q("__to_key")} AS ${q("__key")} FROM ${edgesRelation}
-    ), ${toEndRelation}(${q("__key")}) AS (
-      SELECT ${q("__end_key")}
-      FROM ${endpointRelation}
-      INNER JOIN ${nodesRelation}
-        ON ${q("__end_key")} = ${q("__key")}
-      UNION
-      SELECT ${edgeFromKey}
-      FROM ${toEndRelation} AS ${q("reached")}
-      INNER JOIN ${edgesRelation} AS ${q("edges")}
-        ON ${q("reached")}.${q("__key")} = ${edgeToKey}
-    ), ${bestTotalRelation} AS (
-      SELECT MIN(${q("costs")}.${q(metrics.minimize === "steps" ? "steps" : "distance")}) AS ${q("distance")}
-      FROM ${costs.costRelation} AS ${q("costs")}
-      INNER JOIN ${endpointRelation}
-        ON ${q("costs")}.${q("__node_key")} = ${q("__end_key")}
-    ), ${routesRelation}(
-      ${q("node")}, ${q("__node_key")}, ${q("__visited")},
-      ${q("__edge_keys")}, ${q("steps")}, ${q("distance")},
-      ${q("__event_id")}, ${q("__event_start")}, ${q("__event_end")}${metrics.elapsedTime ? `, ${q("__journey_anchor")}, ${q("__elapsed")}` : ""}
-    ) AS (
-      SELECT ${edgeTo}, ${edgeToKey},
-        [${q("__start_key")}, ${edgeToKey}], [${edgeKey}],
-        [${step(edgeCost, firstElapsed)}], ${edgeCost},
-        ${q("edges")}.${q("__event_id")},
-        ${q("edges")}.${q("__event_start")},
-        ${q("edges")}.${q("__event_end")}${metrics.elapsedTime ? `, ${firstAnchor}, ${firstElapsed}` : ""}
-      FROM ${endpointRelation}
-      INNER JOIN ${edgesRelation} AS ${q("edges")}
-        ON ${q("__start_key")} = ${edgeFromKey}
-      INNER JOIN ${toEndRelation} AS ${q("can_reach_end")}
-        ON ${edgeToKey} = ${q("can_reach_end")}.${q("__key")}
-      INNER JOIN ${bestTotalRelation} AS ${q("best_total")}
-        ON ${firstMetric} <= ${q("best_total")}.${q("distance")}
-      WHERE ${q("__start_key")} <> ${edgeToKey}
-      UNION ALL
-      SELECT ${edgeTo}, ${edgeToKey},
-        list_append(${q("routes")}.${q("__visited")}, ${edgeToKey}),
-        list_append(${q("routes")}.${q("__edge_keys")}, ${edgeKey}),
-        list_append(${q("routes")}.${q("steps")}, ${step(candidateDistance, candidateElapsed)}),
-        ${candidateDistance}, ${q("edges")}.${q("__event_id")},
-        ${q("edges")}.${q("__event_start")},
-        ${q("edges")}.${q("__event_end")}${metrics.elapsedTime ? `, ${routeAnchor}, ${candidateElapsed}` : ""}
-      FROM ${routesRelation} AS ${q("routes")}
-      INNER JOIN ${edgesRelation} AS ${q("edges")}
-        ON ${q("routes")}.${q("__node_key")} = ${edgeFromKey}
-      INNER JOIN ${toEndRelation} AS ${q("can_reach_end")}
-        ON ${edgeToKey} = ${q("can_reach_end")}.${q("__key")}
-      INNER JOIN ${bestTotalRelation} AS ${q("best_total")}
-        ON ${candidateMetric} <= ${q("best_total")}.${q("distance")}
-      CROSS JOIN ${endpointRelation}
-      CROSS JOIN ${costs.settingsRelation} AS ${q("settings")}
-      WHERE ${q("routes")}.${q("__node_key")} <> ${q("__end_key")}
-        AND NOT list_contains(${q("routes")}.${q("__visited")}, ${edgeToKey})
-        AND ${temporal.transition("routes", "edges", direction, gap)}
-    ), ${shortestRelation} AS (
-      SELECT ${q("__edge_keys")}, ${q("steps")}
-      FROM ${routesRelation} AS ${q("routes")}
-      CROSS JOIN ${endpointRelation}
-      CROSS JOIN ${bestTotalRelation} AS ${q("best_total")}
-      WHERE ${q("__node_key")} = ${q("__end_key")}
-        AND ${routeMetric} = ${q("best_total")}.${q("distance")}
-    ), ${rankedRelation} AS (
-      SELECT CAST(row_number() OVER (ORDER BY ${q("__edge_keys")}) - 1 AS BIGINT)
-          AS ${q("pathId")}, ${q("steps")}
-      FROM ${shortestRelation}
-    )
-    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn, false, metrics.elapsedTime, includeTotal)}`;
-}
-// At the same physical event a later departure (or earlier incoming arrival)
-// dominates every future elapsed duration. Keyed improvements find the optimum
-// without enumerating route histories; reconstruction still retains all ties.
-function buildElapsedShortestPathCostSql(route, startsSelect, direction, temporal) {
-    const prepared = route.traversal;
-    const q = quoteIdentifier;
-    const relations = prepared.relationNames([
-        "graph_starts",
-        "graph_temporal_settings",
-        "graph_event_rows",
-        "graph_edges",
-        "graph_cost_states",
-    ]);
-    const startsRelation = relations.graph_starts;
-    const settingsRelation = relations.graph_temporal_settings;
-    const eventRowsRelation = relations.graph_event_rows;
-    const edgesRelation = relations.graph_edges;
-    const costRelation = relations.graph_cost_states;
-    const start = `${q("starts")}.${q("start")}`;
-    const startKey = `${q("starts")}.${q("__key")}`;
-    const reachedStart = `${q("reached")}.${q("start")}`;
-    const reachedStartKey = `${q("reached")}.${q("__start_key")}`;
-    const reachedNodeKey = `${q("reached")}.${q("__node_key")}`;
-    const edgeTo = `${q("edges")}.${q("__to")}`;
-    const edgeToKey = `${q("edges")}.${q("__to_key")}`;
-    const edgeFromKey = `${q("edges")}.${q("__from_key")}`;
-    const eventId = `${q("edges")}.${q("__event_id")}`;
-    const eventStart = `${q("edges")}.${q("__event_start")}`;
-    const eventEnd = `${q("edges")}.${q("__event_end")}`;
-    const bestDistance = `${q("best")}.${q("distance")}`;
-    const gap = `${q("settings")}.${q("__gap")}`;
-    const firstAnchor = temporal.journeyAnchor("edges", direction);
-    const reachedAnchor = `${q("reached")}.${q("__journey_anchor")}`;
-    const firstElapsed = temporal.journeyElapsed("edges", firstAnchor, direction);
-    const candidateDistance = temporal.journeyElapsed("edges", reachedAnchor, direction);
-    const bestAnchor = `${direction === "outgoing" ? "MAX" : "MIN"}(${reachedAnchor})`;
-    return {
-        costRelation,
-        edgesRelation,
-        settingsRelation,
-        startsRelation,
-        withClause: `WITH RECURSIVE ${settingsRelation} AS MATERIALIZED (
-      SELECT CAST(? AS HUGEINT) AS ${q("__gap")}
-    ), ${eventRowsRelation} AS MATERIALIZED (
-      ${prepared.edges(direction, [
-            `${route.edgeWeight} AS ${q("__weight")}`,
-            `${route.typedEdgeId} AS ${q("__edge_id")}`,
-            `${route.edgeKey} AS ${q("__edge_key")}`,
-            ...temporal.eventSelections("edges"),
-        ])}
-    ), ${edgesRelation} AS MATERIALIZED (
-      SELECT *
-      FROM ${eventRowsRelation} AS ${q("events")}
-      WHERE ${temporal.eventValidity("events")}
-    ), ${startsRelation} AS MATERIALIZED (
-      ${startsSelect}
-    ), ${costRelation}(
-      ${q("start")}, ${q("node")},
-      ${q("__start_key")}, ${q("__node_key")},
-      ${q("__event_id")}, ${q("__event_start")}, ${q("__event_end")},
-      ${q("distance")}, ${q("__journey_anchor")}
-    ) USING KEY(${q("__start_key")}, ${q("__event_id")}) AS (
-      SELECT ${start}, ${edgeTo}, ${startKey}, ${edgeToKey},
-        ${eventId}, ${eventStart}, ${eventEnd}, ${firstElapsed}, ${firstAnchor}
-      FROM ${startsRelation} AS ${q("starts")}
-      INNER JOIN ${edgesRelation} AS ${q("edges")}
-        ON ${startKey} = ${edgeFromKey}
-      UNION
-      SELECT ${reachedStart}, ${edgeTo}, ${reachedStartKey}, ${edgeToKey},
-        ${eventId}, ${eventStart}, ${eventEnd},
-        MIN(${candidateDistance}) AS ${q("distance")}, ${bestAnchor}
-      FROM ${costRelation} AS ${q("reached")}
-      INNER JOIN ${edgesRelation} AS ${q("edges")}
-        ON ${reachedNodeKey} = ${edgeFromKey}
-      CROSS JOIN ${settingsRelation} AS ${q("settings")}
-      LEFT JOIN recurring.${costRelation} AS ${q("best")}
-        ON ${reachedStartKey} = ${q("best")}.${q("__start_key")}
-        AND ${eventId} = ${q("best")}.${q("__event_id")}
-      WHERE ${temporal.transition("reached", "edges", direction, gap)}
-      GROUP BY ${reachedStart}, ${edgeTo}, ${reachedStartKey}, ${edgeToKey},
-        ${eventId}, ${eventStart}, ${eventEnd}, ${bestDistance}
-      HAVING ${bestDistance} IS NULL OR
-        MIN(${candidateDistance}) < ${bestDistance}
-    )`,
-    };
-}

package/esm/methods/similarityMahalanobis.d.ts

@@ -1,7 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-type Options = NonNullable<Parameters<SimpleTable["similarityMahalanobis"]>[3]>;
-export default function similarityMahalanobis(table: SimpleTable, columns: string | string[], referencePoint: number[] | {
-    [key: string]: unknown;
-}, newColumn: string, options?: Options): void;
-export {};
-//# sourceMappingURL=similarityMahalanobis.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"similarityMahalanobis.d.ts","sourceRoot":"","sources":["../../src/methods/similarityMahalanobis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AASvD,KAAK,OAAO,GAAG,WAAW,CAAC,UAAU,CAAC,WAAW,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAEhF,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAC3C,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAC1B,cAAc,EAAE,MAAM,EAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EACrD,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,OAAY,GACpB,IAAI,CAsDN"}