@nshiab/simple-data-analysis-core 2.1.5 → 2.1.7

package/esm/methods/shortestPath.js

@@ -1,4 +1,5 @@
 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";
@@ -31,6 +32,7 @@ export default function shortestPath(simpleTable, sourceColumn, targetColumn, ed
         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()");
@@ -59,22 +61,22 @@ export default function shortestPath(simpleTable, sourceColumn, targetColumn, ed
                 ? endpoints.values.values
                 : [temporal.gapParameter, ...endpoints.values.values];
         },
-        buildSelect: (input, schema) => shortestPathSelect(input, schema, sourceColumn, targetColumn, edgeId, endpoints, direction, options.weight, temporalOptions),
+        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()");
             if (temporalOptions !== undefined) {
                 prepareGraphTemporalSql(schema, temporalOptions, "shortestPath()");
             }
-            return graphRouteResultSchema(schema, validated.distanceType, "shortestPath()");
+            return graphRouteResultSchema(schema, validated.distanceType, "shortestPath()", metrics.elapsedTime);
         },
     });
 }
-function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoints, direction, weight, temporalOptions) {
+function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoints, direction, weight, temporalOptions, metrics) {
     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);
+        return temporalShortestPathSelect(route, direction, temporal, metrics);
     }
     const distanceType = route.distanceType;
     // Exact shortest routes have optimal prefixes. Floating addition can erase
@@ -211,7 +213,7 @@ function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoint
     )
     ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn)}`;
 }
-function temporalShortestPathSelect(route, direction, temporal) {
+function temporalShortestPathSelect(route, direction, temporal, metrics) {
     const prepared = route.traversal;
     const q = quoteIdentifier;
     const startsSelect = `SELECT ${q("start")},
@@ -219,10 +221,12 @@ function temporalShortestPathSelect(route, direction, temporal) {
       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 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")}`,
+        ]);
     const relations = prepared.relationNames([
         "graph_route_endpoints",
         "graph_nodes",
@@ -248,12 +252,27 @@ function temporalShortestPathSelect(route, direction, temporal) {
     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(
+    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 === "elapsedTime"
+        ? firstElapsed
+        : edgeCost;
+    const candidateMetric = metrics.minimize === "elapsedTime"
+        ? candidateElapsed
+        : candidateDistance;
+    const routeMetric = metrics.minimize === "elapsedTime"
+        ? `${q("routes")}.${q("__elapsed")}`
+        : routeDistance;
+    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}
+          ${q("distance")} := ${distance}${metrics.elapsedTime
+        ? `, ${q("elapsedTimeMs")} := ${temporal.elapsedMilliseconds(elapsed)}`
+        : ""}
         )`;
     return `${costs.withClause}, ${endpointRelation}(
       ${q("start")}, ${q("end")}, ${q("__start_key")}, ${q("__end_key")}
@@ -285,37 +304,37 @@ function temporalShortestPathSelect(route, direction, temporal) {
     ), ${routesRelation}(
       ${q("node")}, ${q("__node_key")}, ${q("__visited")},
       ${q("__edge_keys")}, ${q("steps")}, ${q("distance")},
-      ${q("__event_id")}, ${q("__event_start")}, ${q("__event_end")}
+      ${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)}], ${edgeCost},
+        [${step(edgeCost, firstElapsed)}], ${edgeCost},
         ${q("edges")}.${q("__event_id")},
         ${q("edges")}.${q("__event_start")},
-        ${q("edges")}.${q("__event_end")}
+        ${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 ${edgeCost} <= ${q("best_total")}.${q("distance")}
+        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)}),
+        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")}
+        ${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 ${candidateDistance} <= ${q("best_total")}.${q("distance")}
+        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")}
@@ -327,11 +346,97 @@ function temporalShortestPathSelect(route, direction, temporal) {
       CROSS JOIN ${endpointRelation}
       CROSS JOIN ${bestTotalRelation} AS ${q("best_total")}
       WHERE ${q("__node_key")} = ${q("__end_key")}
-        AND ${routeDistance} = ${q("best_total")}.${q("distance")}
+        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)}`;
+    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn, false, metrics.elapsedTime)}`;
+}
+// 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}
+    )`,
+    };
 }