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

package/script/methods/reachable.js

@@ -0,0 +1,170 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = reachable;
+const buildGraphTemporalReachabilitySql_js_1 = __importDefault(require("../helpers/buildGraphTemporalReachabilitySql.js"));
+const prepareGraphTemporalSql_js_1 = __importStar(require("../helpers/prepareGraphTemporalSql.js"));
+const prepareGraphStarts_js_1 = __importDefault(require("../helpers/prepareGraphStarts.js"));
+const prepareGraphTraversal_js_1 = __importStar(require("../helpers/prepareGraphTraversal.js"));
+const queueGraphResult_js_1 = __importDefault(require("../helpers/queueGraphResult.js"));
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const validateGraphTemporalEvents_js_1 = __importDefault(require("../helpers/validateGraphTemporalEvents.js"));
+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 = (0, prepareGraphStarts_js_1.default)(startNodes, "reachable()", "startNodes");
+    const direction = options.direction ?? "outgoing";
+    const temporalOptions = (0, prepareGraphTemporalSql_js_1.prepareGraphTemporalOptions)(options, direction, "reachable()");
+    options = structuredClone(options);
+    const parameters = {
+        sourceColumn,
+        targetColumn,
+        startNodes: structuredClone(startNodes),
+        options,
+    };
+    return (0, queueGraphResult_js_1.default)(simpleTable, {
+        method: "reachable()",
+        parameters,
+        outputTable: options.outputTable,
+        preflight: temporalOptions === undefined
+            ? undefined
+            : (input) => (0, validateGraphTemporalEvents_js_1.default)(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 = (0, prepareGraphTraversal_js_1.validateGraphStarts)(schema, source, target, starts, "reachable()", "startNodes");
+    const temporal = temporalOptions === undefined
+        ? undefined
+        : (0, prepareGraphTemporalSql_js_1.default)(schema, temporalOptions, "reachable()");
+    return { endpoints, temporal };
+}
+function reachableSelect(input, schema, source, target, starts, direction, temporalOptions) {
+    const prepared = (0, prepareGraphTraversal_js_1.default)(input, schema, source, target, starts, "reachable()", "startNodes");
+    if (temporalOptions !== undefined) {
+        const temporal = (0, prepareGraphTemporalSql_js_1.default)(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 = `${(0, quoteIdentifier_js_1.default)("starts")}.${(0, quoteIdentifier_js_1.default)("start")}`;
+    const startKey = `${(0, quoteIdentifier_js_1.default)("starts")}.${(0, quoteIdentifier_js_1.default)("__key")}`;
+    const reachedStart = `${(0, quoteIdentifier_js_1.default)("reached")}.${(0, quoteIdentifier_js_1.default)("start")}`;
+    const reachedStartKey = `${(0, quoteIdentifier_js_1.default)("reached")}.${(0, quoteIdentifier_js_1.default)("__start_key")}`;
+    const edgeTo = `${(0, quoteIdentifier_js_1.default)("edges")}.${(0, quoteIdentifier_js_1.default)("__to")}`;
+    const edgeToKey = `${(0, quoteIdentifier_js_1.default)("edges")}.${(0, quoteIdentifier_js_1.default)("__to_key")}`;
+    const edgeFromKey = `${(0, quoteIdentifier_js_1.default)("edges")}.${(0, quoteIdentifier_js_1.default)("__from_key")}`;
+    const reachedNodeKey = `${(0, quoteIdentifier_js_1.default)("reached")}.${(0, quoteIdentifier_js_1.default)("__node_key")}`;
+    return `WITH RECURSIVE ${startValuesRelation}(${(0, quoteIdentifier_js_1.default)("start")}) AS (
+      VALUES ${prepared.startValues}
+    ), ${startsRelation} AS (
+      SELECT ${(0, quoteIdentifier_js_1.default)("start")},
+        ${prepared.key((0, quoteIdentifier_js_1.default)("start"))} AS ${(0, quoteIdentifier_js_1.default)("__key")}
+      FROM ${startValuesRelation}
+    ), ${edgesRelation} AS (
+      ${prepared.edges(direction)}
+    ), ${reachableRelation}(
+      ${(0, quoteIdentifier_js_1.default)("start")}, ${(0, quoteIdentifier_js_1.default)("node")},
+      ${(0, quoteIdentifier_js_1.default)("__start_key")}, ${(0, quoteIdentifier_js_1.default)("__node_key")}
+    ) AS (
+      SELECT ${start}, ${edgeTo}, ${startKey}, ${edgeToKey}
+      FROM ${startsRelation} AS ${(0, quoteIdentifier_js_1.default)("starts")}
+      INNER JOIN ${edgesRelation} AS ${(0, quoteIdentifier_js_1.default)("edges")}
+        ON ${startKey} = ${edgeFromKey}
+      UNION
+      SELECT ${reachedStart}, ${edgeTo}, ${reachedStartKey}, ${edgeToKey}
+      FROM ${reachableRelation} AS ${(0, quoteIdentifier_js_1.default)("reached")}
+      INNER JOIN ${edgesRelation} AS ${(0, quoteIdentifier_js_1.default)("edges")}
+        ON ${reachedNodeKey} = ${edgeFromKey}
+    )
+    SELECT ${(0, quoteIdentifier_js_1.default)("start")}, ${(0, quoteIdentifier_js_1.default)("node")}
+    FROM ${reachableRelation}
+    ORDER BY ${(0, quoteIdentifier_js_1.default)("__start_key")}, ${(0, quoteIdentifier_js_1.default)("__node_key")}`;
+}
+function temporalReachableSelect(prepared, direction, temporal) {
+    const q = quoteIdentifier_js_1.default;
+    const startsSelect = `SELECT ${q("start")},
+        ${prepared.key(q("start"))} AS ${q("__key")}
+      FROM (VALUES ${prepared.startValues}) AS ${q("start_values")}(${q("start")})`;
+    const reachability = (0, buildGraphTemporalReachabilitySql_js_1.default)(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/script/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/script/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/script/methods/rowToVector.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = rowToVector;
+const foldIdentifier_js_1 = __importDefault(require("../helpers/foldIdentifier.js"));
+const prepareNumericFeatures_js_1 = require("../helpers/prepareNumericFeatures.js");
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+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 ${(0, quoteIdentifier_js_1.default)(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);
+    (0, queueOp_js_1.default)(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 = (0, quoteIdentifier_js_1.default)(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 ${(0, quoteIdentifier_js_1.default)(newColumn)} FROM ${input}`;
+        },
+    });
+}
+function resolveElementType(schema, columns, newColumn, options) {
+    const existingOutput = Object.keys(schema).find((column) => (0, foldIdentifier_js_1.default)(column) === (0, foldIdentifier_js_1.default)(newColumn));
+    if (existingOutput !== undefined) {
+        throw new Error(`rowToVector() the column ${(0, quoteIdentifier_js_1.default)(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) => !(0, prepareNumericFeatures_js_1.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) => `${(0, quoteIdentifier_js_1.default)(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) => `${(0, quoteIdentifier_js_1.default)(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) => (0, foldIdentifier_js_1.default)(column) === (0, foldIdentifier_js_1.default)(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_js_1.default).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 = (0, foldIdentifier_js_1.default)(column);
+        if (seen.has(folded))
+            return column;
+        seen.add(folded);
+    }
+    return undefined;
+}

package/script/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/script/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/script/methods/shortestPath.js

@@ -0,0 +1,376 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = shortestPath;
+const buildGraphTemporalCostStateSql_js_1 = __importDefault(require("../helpers/buildGraphTemporalCostStateSql.js"));
+const prepareGraphRouteSql_js_1 = require("../helpers/prepareGraphRouteSql.js");
+const graphRouteResultSchema_js_1 = __importDefault(require("../helpers/graphRouteResultSchema.js"));
+const graphRouteResultSelect_js_1 = __importDefault(require("../helpers/graphRouteResultSelect.js"));
+const prepareGraphTemporalSql_js_1 = __importStar(require("../helpers/prepareGraphTemporalSql.js"));
+const queueGraphResult_js_1 = __importDefault(require("../helpers/queueGraphResult.js"));
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const validateGraphTemporalEvents_js_1 = __importDefault(require("../helpers/validateGraphTemporalEvents.js"));
+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 = (0, prepareGraphRouteSql_js_1.prepareGraphRouteEndpoints)(start, end, "shortestPath()");
+    const direction = options.direction ?? "outgoing";
+    const temporalOptions = (0, prepareGraphTemporalSql_js_1.prepareGraphTemporalOptions)(options, direction, "shortestPath()");
+    options = structuredClone(options);
+    const parameters = {
+        sourceColumn,
+        targetColumn,
+        edgeId,
+        start,
+        end,
+        options,
+    };
+    return (0, queueGraphResult_js_1.default)(simpleTable, {
+        method: "shortestPath()",
+        parameters,
+        outputTable: options.outputTable,
+        preflight: temporalOptions === undefined
+            ? undefined
+            : (input) => (0, validateGraphTemporalEvents_js_1.default)(input, temporalOptions, "shortestPath()", parameters),
+        values: (schema) => {
+            (0, prepareGraphRouteSql_js_1.validateGraphRouteInputs)(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "shortestPath()");
+            const temporal = temporalOptions === undefined
+                ? undefined
+                : (0, prepareGraphTemporalSql_js_1.default)(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 = (0, prepareGraphRouteSql_js_1.validateGraphRouteInputs)(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "shortestPath()");
+            if (temporalOptions !== undefined) {
+                (0, prepareGraphTemporalSql_js_1.default)(schema, temporalOptions, "shortestPath()");
+            }
+            return (0, graphRouteResultSchema_js_1.default)(schema, validated.distanceType, "shortestPath()");
+        },
+    });
+}
+function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoints, direction, weight, temporalOptions) {
+    const route = (0, prepareGraphRouteSql_js_1.prepareGraphRouteSql)(input, schema, source, target, edgeId, routeEndpoints, weight, "shortestPath()");
+    const prepared = route.traversal;
+    if (temporalOptions !== undefined) {
+        const temporal = (0, prepareGraphTemporalSql_js_1.default)(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_js_1.default;
+    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}
+    )
+    ${(0, graphRouteResultSelect_js_1.default)(rankedRelation, route.input, route.edgeIdColumn)}`;
+}
+function temporalShortestPathSelect(route, direction, temporal) {
+    const prepared = route.traversal;
+    const q = quoteIdentifier_js_1.default;
+    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 = (0, buildGraphTemporalCostStateSql_js_1.default)(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}
+    )
+    ${(0, graphRouteResultSelect_js_1.default)(rankedRelation, route.input, route.edgeIdColumn)}`;
+}