@nshiab/simple-data-analysis-core 2.0.8 → 2.1.0

package/esm/methods/reachable.js

@@ -0,0 +1,131 @@
+import buildGraphTemporalReachabilitySql from "../helpers/buildGraphTemporalReachabilitySql.js";
+import prepareGraphTemporalSql, { prepareGraphTemporalOptions, } from "../helpers/prepareGraphTemporalSql.js";
+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";
+import validateGraphTemporalEvents from "../helpers/validateGraphTemporalEvents.js";
+export default function reachable(simpleTable, sourceColumn, targetColumn, startNodes, options = {}) {
+    if (typeof sourceColumn !== "string") {
+        throw new TypeError("reachable() sourceColumn must be a string.");
+    }
+    if (typeof targetColumn !== "string") {
+        throw new TypeError("reachable() targetColumn must be a string.");
+    }
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+        throw new TypeError("reachable() options must be an object.");
+    }
+    if (options.direction !== undefined &&
+        !["outgoing", "incoming", "both"].includes(options.direction)) {
+        throw new TypeError('reachable() options.direction must be "outgoing", "incoming", or "both".');
+    }
+    if (options.outputTable !== undefined &&
+        typeof options.outputTable !== "string" &&
+        typeof options.outputTable !== "boolean") {
+        throw new TypeError("reachable() options.outputTable must be a string or boolean.");
+    }
+    const preparedStarts = prepareGraphStarts(startNodes, "reachable()", "startNodes");
+    const direction = options.direction ?? "outgoing";
+    const temporalOptions = prepareGraphTemporalOptions(options, direction, "reachable()");
+    options = structuredClone(options);
+    const parameters = {
+        sourceColumn,
+        targetColumn,
+        startNodes: structuredClone(startNodes),
+        options,
+    };
+    return queueGraphResult(simpleTable, {
+        method: "reachable()",
+        parameters,
+        outputTable: options.outputTable,
+        preflight: temporalOptions === undefined
+            ? undefined
+            : (input) => validateGraphTemporalEvents(input, temporalOptions, "reachable()", parameters),
+        values: (schema) => {
+            const { temporal } = validateInputs(schema, sourceColumn, targetColumn, preparedStarts, temporalOptions);
+            return temporal === undefined
+                ? preparedStarts.values
+                : [temporal.gapParameter, ...preparedStarts.values];
+        },
+        buildSelect: (input, schema) => reachableSelect(input, schema, sourceColumn, targetColumn, preparedStarts, direction, temporalOptions),
+        outputSchema: (schema) => {
+            const { endpoints } = validateInputs(schema, sourceColumn, targetColumn, preparedStarts, temporalOptions);
+            return {
+                start: endpoints.idType,
+                node: endpoints.idType,
+            };
+        },
+    });
+}
+function validateInputs(schema, source, target, starts, temporalOptions) {
+    const endpoints = validateGraphStarts(schema, source, target, starts, "reachable()", "startNodes");
+    const temporal = temporalOptions === undefined
+        ? undefined
+        : prepareGraphTemporalSql(schema, temporalOptions, "reachable()");
+    return { endpoints, temporal };
+}
+function reachableSelect(input, schema, source, target, starts, direction, temporalOptions) {
+    const prepared = prepareGraphTraversal(input, schema, source, target, starts, "reachable()", "startNodes");
+    if (temporalOptions !== undefined) {
+        const temporal = prepareGraphTemporalSql(schema, temporalOptions, "reachable()");
+        return temporalReachableSelect(prepared, direction, temporal);
+    }
+    const relations = prepared.relationNames([
+        "graph_start_values",
+        "graph_starts",
+        "graph_edges",
+        "graph_reachable",
+    ]);
+    const startValuesRelation = relations.graph_start_values;
+    const startsRelation = relations.graph_starts;
+    const edgesRelation = relations.graph_edges;
+    const reachableRelation = relations.graph_reachable;
+    const start = `${quoteIdentifier("starts")}.${quoteIdentifier("start")}`;
+    const startKey = `${quoteIdentifier("starts")}.${quoteIdentifier("__key")}`;
+    const reachedStart = `${quoteIdentifier("reached")}.${quoteIdentifier("start")}`;
+    const reachedStartKey = `${quoteIdentifier("reached")}.${quoteIdentifier("__start_key")}`;
+    const edgeTo = `${quoteIdentifier("edges")}.${quoteIdentifier("__to")}`;
+    const edgeToKey = `${quoteIdentifier("edges")}.${quoteIdentifier("__to_key")}`;
+    const edgeFromKey = `${quoteIdentifier("edges")}.${quoteIdentifier("__from_key")}`;
+    const reachedNodeKey = `${quoteIdentifier("reached")}.${quoteIdentifier("__node_key")}`;
+    return `WITH RECURSIVE ${startValuesRelation}(${quoteIdentifier("start")}) AS (
+      VALUES ${prepared.startValues}
+    ), ${startsRelation} AS (
+      SELECT ${quoteIdentifier("start")},
+        ${prepared.key(quoteIdentifier("start"))} AS ${quoteIdentifier("__key")}
+      FROM ${startValuesRelation}
+    ), ${edgesRelation} AS (
+      ${prepared.edges(direction)}
+    ), ${reachableRelation}(
+      ${quoteIdentifier("start")}, ${quoteIdentifier("node")},
+      ${quoteIdentifier("__start_key")}, ${quoteIdentifier("__node_key")}
+    ) AS (
+      SELECT ${start}, ${edgeTo}, ${startKey}, ${edgeToKey}
+      FROM ${startsRelation} AS ${quoteIdentifier("starts")}
+      INNER JOIN ${edgesRelation} AS ${quoteIdentifier("edges")}
+        ON ${startKey} = ${edgeFromKey}
+      UNION
+      SELECT ${reachedStart}, ${edgeTo}, ${reachedStartKey}, ${edgeToKey}
+      FROM ${reachableRelation} AS ${quoteIdentifier("reached")}
+      INNER JOIN ${edgesRelation} AS ${quoteIdentifier("edges")}
+        ON ${reachedNodeKey} = ${edgeFromKey}
+    )
+    SELECT ${quoteIdentifier("start")}, ${quoteIdentifier("node")}
+    FROM ${reachableRelation}
+    ORDER BY ${quoteIdentifier("__start_key")}, ${quoteIdentifier("__node_key")}`;
+}
+function temporalReachableSelect(prepared, direction, temporal) {
+    const q = quoteIdentifier;
+    const startsSelect = `SELECT ${q("start")},
+        ${prepared.key(q("start"))} AS ${q("__key")}
+      FROM (VALUES ${prepared.startValues}) AS ${q("start_values")}(${q("start")})`;
+    const reachability = buildGraphTemporalReachabilitySql(prepared, startsSelect, direction, temporal);
+    return `${reachability.withClause}
+    SELECT ${q("start")}, ${q("node")}
+    FROM (
+      SELECT DISTINCT ${q("start")}, ${q("node")},
+        ${q("__start_key")}, ${q("__node_key")}
+      FROM ${reachability.reachableRelation}
+    ) AS ${q("reachable_nodes")}
+    ORDER BY ${q("__start_key")}, ${q("__node_key")}`;
+}

package/esm/methods/rowToVector.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"rowToVector.d.ts","sourceRoot":"","sources":["../../src/methods/rowToVector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAOvD,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAA;CAAO,QAyD5C"}

package/esm/methods/rowToVector.js

@@ -0,0 +1,77 @@
+import foldIdentifier from "../helpers/foldIdentifier.js";
+import { isNumericScalarType } from "../helpers/prepareNumericFeatures.js";
+import queueOp from "../helpers/queueOp.js";
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+export default function rowToVector(table, columns, newColumn, options = {}) {
+    if (columns.length === 0) {
+        throw new Error("rowToVector() requires at least one numeric scalar input column.");
+    }
+    const duplicate = findDuplicate(columns);
+    if (duplicate !== undefined) {
+        throw new Error(`rowToVector() received duplicate input column ${quoteIdentifier(duplicate)}. Each input column must be listed once.`);
+    }
+    if (options.type !== undefined && !["float", "double"].includes(options.type)) {
+        throw new Error('rowToVector() options.type must be "float" or "double".');
+    }
+    columns = [...columns];
+    options = structuredClone(options);
+    queueOp(table, {
+        kind: "fusable",
+        method: "rowToVector()",
+        parameters: { columns, newColumn, options },
+        needsSchema: true,
+        outputSchema: (schema) => ({
+            ...schema,
+            [newColumn]: `${resolveElementType(schema, columns, newColumn, options)}[${columns.length}]`,
+        }),
+        buildSelect: (input, schema) => {
+            const elementType = resolveElementType(schema, columns, newColumn, options);
+            const resolved = resolveColumns(schema, columns);
+            return `SELECT *, [${resolved.map((column) => {
+                const value = quoteIdentifier(column);
+                // DuckDB does not implement a direct BIGNUM-to-FLOAT cast.
+                const convertible = schema[column] === "BIGNUM" && elementType === "FLOAT"
+                    ? `${value}::VARCHAR`
+                    : value;
+                return `${convertible}::${elementType}`;
+            }).join(", ")}]::${elementType}[${columns.length}] AS ${quoteIdentifier(newColumn)} FROM ${input}`;
+        },
+    });
+}
+function resolveElementType(schema, columns, newColumn, options) {
+    const existingOutput = Object.keys(schema).find((column) => foldIdentifier(column) === foldIdentifier(newColumn));
+    if (existingOutput !== undefined) {
+        throw new Error(`rowToVector() the column ${quoteIdentifier(newColumn)} already exists. Remove it first or choose a different name for the new column.`);
+    }
+    const resolved = resolveColumns(schema, columns);
+    const nonNumeric = resolved.filter((column) => !isNumericScalarType(schema[column]));
+    if (nonNumeric.length > 0) {
+        throw new Error(`rowToVector() requires numeric scalar input columns. The following columns are not numeric: ${nonNumeric.map((column) => `${quoteIdentifier(column)} (${schema[column]})`).join(", ")}. Convert them to numeric types first.`);
+    }
+    if (options.type !== undefined)
+        return options.type.toUpperCase();
+    const inputTypes = resolved.map((column) => schema[column]);
+    if (new Set(inputTypes).size !== 1) {
+        throw new Error(`rowToVector() cannot infer one vector element type from columns with different types: ${resolved.map((column) => `${quoteIdentifier(column)} (${schema[column]})`).join(", ")}. Set options.type to "float" or "double".`);
+    }
+    return inputTypes[0];
+}
+function resolveColumns(schema, columns) {
+    const available = Object.keys(schema);
+    const resolved = columns.map((requested) => available.find((column) => foldIdentifier(column) === foldIdentifier(requested)));
+    const missing = columns.filter((_, index) => resolved[index] === undefined);
+    if (missing.length > 0) {
+        throw new Error(`rowToVector() the column${missing.length > 1 ? "s" : ""} ${missing.map(quoteIdentifier).join(", ")} ${missing.length > 1 ? "do" : "does"} not exist. Check for typos, or load the data first.`);
+    }
+    return resolved;
+}
+function findDuplicate(columns) {
+    const seen = new Set();
+    for (const column of columns) {
+        const folded = foldIdentifier(column);
+        if (seen.has(folded))
+            return column;
+        seen.add(folded);
+    }
+    return undefined;
+}

package/esm/methods/shortestPath.d.ts

@@ -0,0 +1,12 @@
+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;
+};
+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

@@ -0,0 +1 @@
+{"version":3,"file":"shortestPath.d.ts","sourceRoot":"","sources":["../../src/methods/shortestPath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,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;CACjB,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,CAmHb"}

package/esm/methods/shortestPath.js

@@ -0,0 +1,337 @@
+import buildGraphTemporalCostStateSql from "../helpers/buildGraphTemporalCostStateSql.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 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()");
+            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),
+        outputSchema: (schema) => {
+            const validated = validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "shortestPath()");
+            if (temporalOptions !== undefined) {
+                prepareGraphTemporalSql(schema, temporalOptions, "shortestPath()");
+            }
+            return graphRouteResultSchema(schema, validated.distanceType, "shortestPath()");
+        },
+    });
+}
+function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoints, direction, weight, temporalOptions) {
+    const route = prepareGraphRouteSql(input, schema, source, target, edgeId, routeEndpoints, weight, "shortestPath()");
+    const prepared = route.traversal;
+    if (temporalOptions !== undefined) {
+        const temporal = prepareGraphTemporalSql(schema, temporalOptions, "shortestPath()");
+        return temporalShortestPathSelect(route, direction, temporal);
+    }
+    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 = route.weightType === "FLOAT" ||
+        route.weightType === "DOUBLE";
+    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 routeDistance = `${q("routes")}.${q("distance")}`;
+    const candidateDistance = `CAST(${routeDistance} + ${edgeCost} AS ${distanceType})`;
+    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 ${distanceType})
+      FROM ${endpointRelation}
+      INNER JOIN ${toEndRelation}
+        ON ${q("__start_key")} = ${q("__key")}
+      UNION
+      SELECT ${edgeTo}, ${edgeToKey},
+        MIN(CAST(${q("reached")}.${q("distance")} + ${edgeCost} AS ${distanceType}))
+      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")} + ${edgeCost} AS ${distanceType})) < ${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
+        ? `${candidateDistance} <= ${q("best_total")}.${q("distance")}`
+        : `${candidateDistance} = ${q("best_prefix")}.${q("distance")}`}
+    ), ${shortestRelation} AS (
+      SELECT ${q("__edge_keys")}, ${q("steps")}
+      FROM ${routesRelation}
+      CROSS JOIN ${endpointRelation}
+      CROSS JOIN ${bestTotalRelation} AS ${q("best_total")}
+      WHERE ${q("__node_key")} = ${q("__end_key")}
+        AND ${routesRelation}.${q("distance")} = ${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)}`;
+}
+function temporalShortestPathSelect(route, direction, temporal) {
+    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 = buildGraphTemporalCostStateSql(prepared, startsSelect, direction, temporal, route.distanceType, route.edgeWeight, [
+        `${route.typedEdgeId} AS ${q("__edge_id")}`,
+        `${route.edgeKey} AS ${q("__edge_key")}`,
+    ]);
+    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 step = (distance) => `struct_pack(
+          ${q("edgeId")} := ${q("edges")}.${q("__edge_id")},
+          ${q("source")} := ${q("edges")}.${q("__from")},
+          ${q("target")} := ${edgeTo},
+          ${q("weight")} := ${edgeCost},
+          ${q("distance")} := ${distance}
+        )`;
+    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("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")}
+    ) AS (
+      SELECT ${edgeTo}, ${edgeToKey},
+        [${q("__start_key")}, ${edgeToKey}], [${edgeKey}],
+        [${step(edgeCost)}], ${edgeCost},
+        ${q("edges")}.${q("__event_id")},
+        ${q("edges")}.${q("__event_start")},
+        ${q("edges")}.${q("__event_end")}
+      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 ${edgeCost} <= ${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)}),
+        ${candidateDistance}, ${q("edges")}.${q("__event_id")},
+        ${q("edges")}.${q("__event_start")},
+        ${q("edges")}.${q("__event_end")}
+      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 ${candidateDistance} <= ${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 ${routeDistance} = ${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)}`;
+}

package/esm/methods/topologicalSort.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"topologicalSort.d.ts","sourceRoot":"","sources":["../../src/methods/topologicalSort.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAQvD,KAAK,sBAAsB,GAAG;IAC5B,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,OAAO,GAAE,sBAA2B,GACnC,WAAW,CAoDb"}