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

package/esm/methods/distances.js

@@ -1,5 +1,6 @@
 import buildGraphTemporalCostStateSql from "../helpers/buildGraphTemporalCostStateSql.js";
 import getGraphWeightColumn from "../helpers/getGraphWeightColumn.js";
+import prepareGraphMetricOptions from "../helpers/prepareGraphMetricOptions.js";
 import prepareGraphTemporalSql, { prepareGraphTemporalOptions, } from "../helpers/prepareGraphTemporalSql.js";
 import prepareGraphStarts from "../helpers/prepareGraphStarts.js";
 import prepareGraphTraversal, { validateGraphStarts, } from "../helpers/prepareGraphTraversal.js";
@@ -28,6 +29,7 @@ export default function distances(simpleTable, sourceColumn, targetColumn, start
         typeof options.outputTable !== "boolean") {
         throw new TypeError("distances() options.outputTable must be a string or boolean.");
     }
+    const metrics = prepareGraphMetricOptions(options, "distances()", true);
     const preparedStarts = prepareGraphStarts(startNodes, "distances()", "startNodes");
     const direction = options.direction ?? "outgoing";
     const temporalOptions = prepareGraphTemporalOptions(options, direction, "distances()");
@@ -51,13 +53,14 @@ export default function distances(simpleTable, sourceColumn, targetColumn, start
                 ? preparedStarts.values
                 : [temporal.gapParameter, ...preparedStarts.values];
         },
-        buildSelect: (input, schema) => distancesSelect(input, schema, sourceColumn, targetColumn, preparedStarts, direction, options.weight, temporalOptions),
+        buildSelect: (input, schema) => distancesSelect(input, schema, sourceColumn, targetColumn, preparedStarts, direction, options.weight, temporalOptions, metrics),
         outputSchema: (schema) => {
             const validated = validateDistanceInputs(schema, sourceColumn, targetColumn, preparedStarts, options.weight, temporalOptions);
             return {
                 start: validated.idType,
                 node: validated.idType,
-                distance: validated.distanceType,
+                total: validated.distanceType,
+                ...(metrics.elapsedTime ? { elapsedTimeMs: "DOUBLE" } : {}),
             };
         },
     });
@@ -72,7 +75,7 @@ function validateDistanceInputs(schema, source, target, starts, weight, temporal
         : prepareGraphTemporalSql(schema, temporalOptions, "distances()");
     return { idType: endpoints.idType, distanceType, temporal };
 }
-function distancesSelect(input, schema, source, target, starts, direction, weight, temporalOptions) {
+function distancesSelect(input, schema, source, target, starts, direction, weight, temporalOptions, metrics) {
     const prepared = prepareGraphTraversal(input, schema, source, target, starts, "distances()", "startNodes");
     const weightColumn = weight === undefined
         ? undefined
@@ -83,6 +86,9 @@ function distancesSelect(input, schema, source, target, starts, direction, weigh
         : `CAST(${quoteIdentifier("edges")}.${quoteIdentifier(weightColumn.column)} AS ${distanceType})`;
     if (temporalOptions !== undefined) {
         const temporal = prepareGraphTemporalSql(schema, temporalOptions, "distances()");
+        if (metrics.elapsedTime) {
+            return elapsedDistancesSelect(prepared, direction, temporal, distanceType, edgeWeight, metrics.minimize);
+        }
         return temporalDistancesSelect(prepared, direction, temporal, distanceType, edgeWeight);
     }
     const relations = prepared.relationNames([
@@ -144,7 +150,7 @@ function distancesSelect(input, schema, source, target, starts, direction, weigh
       HAVING ${bestDistance} IS NULL OR MIN(${candidateDistance}) < ${bestDistance}
     )
     SELECT ${quoteIdentifier("start")}, ${quoteIdentifier("node")},
-      ${quoteIdentifier("distance")}
+      ${quoteIdentifier("distance")} AS ${quoteIdentifier("total")}
     FROM ${distancesRelation}
     ORDER BY ${quoteIdentifier("__start_key")}, ${quoteIdentifier("distance")}, ${quoteIdentifier("__node_key")}`;
 }
@@ -156,9 +162,95 @@ function temporalDistancesSelect(prepared, direction, temporal, distanceType, ed
     const costStates = buildGraphTemporalCostStateSql(prepared, startsSelect, direction, temporal, distanceType, edgeWeight);
     return `${costStates.withClause}
     SELECT ${q("start")}, ${q("node")},
-      MIN(${q("distance")}) AS ${q("distance")}
+      MIN(${q("distance")}) AS ${q("total")}
     FROM ${costStates.costRelation}
     GROUP BY ${q("start")}, ${q("node")}, ${q("__start_key")},
       ${q("__node_key")}
-    ORDER BY ${q("__start_key")}, ${q("distance")}, ${q("__node_key")}`;
+    ORDER BY ${q("__start_key")}, ${q("total")}, ${q("__node_key")}`;
+}
+function elapsedDistancesSelect(prepared, direction, temporal, distanceType, edgeWeight, minimize) {
+    const q = quoteIdentifier;
+    const relations = prepared.relationNames([
+        "graph_starts",
+        "graph_temporal_settings",
+        "graph_event_rows",
+        "graph_edges",
+        "graph_elapsed_states",
+        "graph_elapsed_results",
+    ]);
+    const starts = relations.graph_starts;
+    const settings = relations.graph_temporal_settings;
+    const events = relations.graph_event_rows;
+    const edges = relations.graph_edges;
+    const states = relations.graph_elapsed_states;
+    const results = relations.graph_elapsed_results;
+    const ref = (alias, column) => `${q(alias)}.${q(column)}`;
+    const anchor = temporal.journeyAnchor("edges", direction);
+    const reachedAnchor = ref("reached", "__anchor");
+    const candidateDistance = `CAST(${ref("reached", "distance")} + ${ref("edges", "__weight")} AS ${distanceType})`;
+    const order = minimize === "elapsedTime"
+        ? `${q("__elapsed")}, ${q("distance")}`
+        : `${q("distance")}, ${q("__elapsed")}`;
+    // A physical event and the first departure (last arrival for incoming
+    // traversal) fix elapsed time. Keep the cheapest cost for each such state;
+    // merging different anchors would lose later-departing, faster journeys.
+    // The state space is finite, and strict improvements terminate zero cycles.
+    return `WITH RECURSIVE ${settings} AS MATERIALIZED (
+      SELECT CAST(? AS HUGEINT) AS ${q("__gap")}
+    ), ${events} AS MATERIALIZED (
+      ${prepared.edges(direction, [
+        `${edgeWeight} AS ${q("__weight")}`,
+        ...temporal.eventSelections("edges"),
+    ])}
+    ), ${edges} AS MATERIALIZED (
+      SELECT * FROM ${events} AS ${q("events")}
+      WHERE ${temporal.eventValidity("events")}
+    ), ${starts} AS MATERIALIZED (
+      SELECT ${q("start")}, ${prepared.key(q("start"))} AS ${q("__key")}
+      FROM (VALUES ${prepared.startValues}) AS ${q("start_values")}(${q("start")})
+    ), ${states}(
+      ${q("start")}, ${q("node")}, ${q("__start_key")}, ${q("__node_key")},
+      ${q("__event_id")}, ${q("__event_start")}, ${q("__event_end")},
+      ${q("__anchor")}, ${q("distance")}
+    ) USING KEY(${q("__start_key")}, ${q("__event_id")}, ${q("__anchor")}) AS (
+      SELECT ${ref("starts", "start")}, ${ref("edges", "__to")},
+        ${ref("starts", "__key")}, ${ref("edges", "__to_key")},
+        ${ref("edges", "__event_id")}, ${ref("edges", "__event_start")},
+        ${ref("edges", "__event_end")}, ${anchor}, ${ref("edges", "__weight")}
+      FROM ${starts} AS ${q("starts")}
+      INNER JOIN ${edges} AS ${q("edges")}
+        ON ${ref("starts", "__key")} = ${ref("edges", "__from_key")}
+      UNION
+      SELECT ${ref("reached", "start")}, ${ref("edges", "__to")},
+        ${ref("reached", "__start_key")}, ${ref("edges", "__to_key")},
+        ${ref("edges", "__event_id")}, ${ref("edges", "__event_start")},
+        ${ref("edges", "__event_end")}, ${reachedAnchor},
+        MIN(${candidateDistance}) AS ${q("distance")}
+      FROM ${states} AS ${q("reached")}
+      INNER JOIN ${edges} AS ${q("edges")}
+        ON ${ref("reached", "__node_key")} = ${ref("edges", "__from_key")}
+      CROSS JOIN ${settings} AS ${q("settings")}
+      LEFT JOIN recurring.${states} AS ${q("best")}
+        ON ${ref("reached", "__start_key")} = ${ref("best", "__start_key")}
+        AND ${ref("edges", "__event_id")} = ${ref("best", "__event_id")}
+        AND ${reachedAnchor} = ${ref("best", "__anchor")}
+      WHERE ${temporal.transition("reached", "edges", direction, ref("settings", "__gap"))}
+      GROUP BY ${ref("reached", "start")}, ${ref("edges", "__to")},
+        ${ref("reached", "__start_key")}, ${ref("edges", "__to_key")},
+        ${ref("edges", "__event_id")}, ${ref("edges", "__event_start")},
+        ${ref("edges", "__event_end")}, ${reachedAnchor}, ${ref("best", "distance")}
+      HAVING ${ref("best", "distance")} IS NULL OR
+        MIN(${candidateDistance}) < ${ref("best", "distance")}
+    ), ${results} AS (
+      SELECT *, ${temporal.journeyElapsed("states", ref("states", "__anchor"), direction)} AS ${q("__elapsed")}
+      FROM ${states} AS ${q("states")}
+    )
+    SELECT ${q("start")}, ${q("node")}, ${q("distance")} AS ${q("total")},
+      ${temporal.elapsedMilliseconds(q("__elapsed"))} AS ${q("elapsedTimeMs")}
+    FROM ${results}
+    QUALIFY row_number() OVER (
+      PARTITION BY ${q("__start_key")}, ${q("__node_key")}
+      ORDER BY ${order}, ${q("__event_id")}, ${q("__anchor")}
+    ) = 1
+    ORDER BY ${q("__start_key")}, ${order}, ${q("__node_key")}`;
 }

package/esm/methods/findCycles.d.ts

@@ -3,6 +3,7 @@ import { type GraphTemporalOptions } from "../helpers/prepareGraphTemporalSql.js
 import { type GraphId } from "../helpers/prepareGraphStarts.js";
 import { type GraphDirection } from "../helpers/prepareGraphTraversal.js";
 type FindCyclesOptions = GraphTemporalOptions & {
+    elapsedTime?: boolean;
     direction?: GraphDirection;
     outputTable?: string | boolean;
     weight?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"findCycles.d.ts","sourceRoot":"","sources":["../../src/methods/findCycles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD,OAAgC,EAC9B,KAAK,oBAAoB,EAG1B,MAAM,uCAAuC,CAAC;AAC/C,OAA2B,EACzB,KAAK,OAAO,EAEb,MAAM,kCAAkC,CAAC;AAC1C,OAA8B,EAC5B,KAAK,cAAc,EAEpB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,iBAAiB,GAAG,oBAAoB,GAAG;IAC9C,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,UAAU,CAChC,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,OAAO,GAAG,OAAO,EAAE,EAC/B,OAAO,GAAE,iBAAsB,GAC9B,WAAW,CAuHb"}
+{"version":3,"file":"findCycles.d.ts","sourceRoot":"","sources":["../../src/methods/findCycles.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD,OAAgC,EAC9B,KAAK,oBAAoB,EAG1B,MAAM,uCAAuC,CAAC;AAC/C,OAA2B,EACzB,KAAK,OAAO,EAEb,MAAM,kCAAkC,CAAC;AAC1C,OAA8B,EAC5B,KAAK,cAAc,EAEpB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,iBAAiB,GAAG,oBAAoB,GAAG;IAC9C,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,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,UAAU,CAChC,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,OAAO,GAAG,OAAO,EAAE,EAC/B,OAAO,GAAE,iBAAsB,GAC9B,WAAW,CAgIb"}

package/esm/methods/findCycles.js

@@ -1,3 +1,4 @@
+import prepareGraphMetricOptions from "../helpers/prepareGraphMetricOptions.js";
 import getGraphEdgeIdColumn from "../helpers/getGraphEdgeIdColumn.js";
 import getGraphWeightColumn from "../helpers/getGraphWeightColumn.js";
 import graphRouteResultSchema from "../helpers/graphRouteResultSchema.js";
@@ -35,6 +36,7 @@ export default function findCycles(simpleTable, sourceColumn, targetColumn, edge
         typeof options.outputTable !== "boolean") {
         throw new TypeError("findCycles() options.outputTable must be a string or boolean.");
     }
+    const metric = prepareGraphMetricOptions(options, "findCycles()", false);
     const direction = options.direction ?? "outgoing";
     const temporalOptions = prepareGraphTemporalOptions(options, direction, "findCycles()");
     options = structuredClone(options);
@@ -53,7 +55,8 @@ export default function findCycles(simpleTable, sourceColumn, targetColumn, edge
             ? undefined
             : (input) => validateGraphTemporalEvents(input, temporalOptions, "findCycles()", parameters),
         values: (schema) => {
-            validateFindCyclesInputs(schema, sourceColumn, targetColumn, edgeId, preparedStarts, options.weight);
+            const validated = validateFindCyclesInputs(schema, sourceColumn, targetColumn, edgeId, preparedStarts, options.weight);
+            graphRouteResultSchema(schema, validated.distanceType, "findCycles()", metric.elapsedTime);
             const temporal = temporalOptions === undefined
                 ? undefined
                 : prepareGraphTemporalSql(schema, temporalOptions, "findCycles()");
@@ -61,7 +64,7 @@ export default function findCycles(simpleTable, sourceColumn, targetColumn, edge
                 ? preparedStarts.values
                 : [temporal.gapParameter, ...preparedStarts.values];
         },
-        buildSelect: (input, schema) => findCyclesSelect(input, schema, sourceColumn, targetColumn, edgeId, preparedStarts, direction, options.weight, temporalOptions),
+        buildSelect: (input, schema) => findCyclesSelect(input, schema, sourceColumn, targetColumn, edgeId, preparedStarts, direction, options.weight, temporalOptions, metric.elapsedTime),
         outputSchema: (schema) => {
             const validated = validateFindCyclesInputs(schema, sourceColumn, targetColumn, edgeId, preparedStarts, options.weight);
             if (temporalOptions !== undefined) {
@@ -69,7 +72,7 @@ export default function findCycles(simpleTable, sourceColumn, targetColumn, edge
             }
             return {
                 start: validated.nodeIdType,
-                ...graphRouteResultSchema(schema, validated.distanceType, "findCycles()"),
+                ...graphRouteResultSchema(schema, validated.distanceType, "findCycles()", metric.elapsedTime),
             };
         },
     });
@@ -87,7 +90,7 @@ function validateFindCyclesInputs(schema, source, target, edgeId, starts, weight
         nodeIdType: endpoints.idType,
     };
 }
-function findCyclesSelect(input, schema, source, target, edgeId, starts, direction, weight, temporalOptions) {
+function findCyclesSelect(input, schema, source, target, edgeId, starts, direction, weight, temporalOptions, elapsedTime) {
     const prepared = prepareGraphTraversal(input, schema, source, target, starts, "findCycles()", "startNodes");
     const edgeIdColumn = getGraphEdgeIdColumn(schema, edgeId, "findCycles()");
     const weightColumn = weight === undefined
@@ -103,10 +106,10 @@ function findCyclesSelect(input, schema, source, target, edgeId, starts, directi
     const edgeWeight = weightColumn === undefined
         ? `CAST(1 AS ${distanceType})`
         : `CAST(${q("edges")}.${q(weightColumn.column)} AS ${distanceType})`;
-    const stepType = `STRUCT(${q("edgeId")} ${edgeIdColumn.idType}, ${q("source")} ${prepared.endpoints.idType}, ${q("target")} ${prepared.endpoints.idType}, ${q("weight")} ${distanceType}, ${q("distance")} ${distanceType})`;
+    const stepType = `STRUCT(${q("edgeId")} ${edgeIdColumn.idType}, ${q("source")} ${prepared.endpoints.idType}, ${q("target")} ${prepared.endpoints.idType}, ${q("weight")} ${distanceType}, ${q("distance")} ${distanceType}${elapsedTime ? `, ${q("elapsedTimeMs")} DOUBLE` : ""})`;
     if (temporalOptions !== undefined) {
         const temporal = prepareGraphTemporalSql(schema, temporalOptions, "findCycles()");
-        return temporalFindCyclesSelect(prepared, direction, temporal, typedEdgeId, edgeKey, edgeWeight, distanceType, stepType, input, edgeIdColumn);
+        return temporalFindCyclesSelect(prepared, direction, temporal, typedEdgeId, edgeKey, edgeWeight, distanceType, stepType, input, edgeIdColumn, elapsedTime);
     }
     const relations = prepared.relationNames([
         "graph_start_values",
@@ -210,7 +213,7 @@ function findCyclesSelect(input, schema, source, target, edgeId, starts, directi
     )
     ${graphRouteResultSelect(rankedRelation, input, edgeIdColumn, true)}`;
 }
-function temporalFindCyclesSelect(prepared, direction, temporal, typedEdgeId, edgeKey, edgeWeight, distanceType, stepType, input, edgeIdColumn) {
+function temporalFindCyclesSelect(prepared, direction, temporal, typedEdgeId, edgeKey, edgeWeight, distanceType, stepType, input, edgeIdColumn, elapsedTime) {
     const q = quoteIdentifier;
     const relations = prepared.relationNames([
         "graph_start_values",
@@ -240,12 +243,16 @@ function temporalFindCyclesSelect(prepared, direction, temporal, typedEdgeId, ed
     const walkDistance = `${q("walks")}.${q("distance")}`;
     const candidateDistance = `CAST(${walkDistance} + ${edgeCost} AS ${distanceType})`;
     const gap = `${q("settings")}.${q("__gap")}`;
-    const step = (distance) => `struct_pack(
+    const firstAnchor = temporal.journeyAnchor("edges", direction);
+    const anchor = `${q("walks")}.${q("__journey_anchor")}`;
+    const step = (distance, journeyAnchor) => `struct_pack(
           ${q("edgeId")} := ${edgeIdentity},
           ${q("source")} := ${edgeFrom},
           ${q("target")} := ${edgeTo},
           ${q("weight")} := ${edgeCost},
-          ${q("distance")} := ${distance}
+          ${q("distance")} := ${distance}${elapsedTime
+        ? `, ${q("elapsedTimeMs")} := ${temporal.elapsedMilliseconds(temporal.journeyElapsed("edges", journeyAnchor, direction))}`
+        : ""}
         )`;
     return `WITH RECURSIVE ${settingsRelation} AS MATERIALIZED (
       SELECT CAST(? AS HUGEINT) AS ${q("__gap")}
@@ -271,7 +278,7 @@ function temporalFindCyclesSelect(prepared, direction, temporal, typedEdgeId, ed
       ${q("__node_key")}, ${q("__visited")}, ${q("__event_ids")},
       ${q("__edge_keys")}, ${q("steps")}, ${q("distance")},
       ${q("closed")}, ${q("__event_id")}, ${q("__event_start")},
-      ${q("__event_end")}
+      ${q("__event_end")}${elapsedTime ? `, ${q("__journey_anchor")}` : ""}
     ) AS (
       SELECT ${q("starts")}.${q("start")},
         ${q("starts")}.${q("__start_key")}, ${edgeTo}, ${edgeToKey},
@@ -280,11 +287,11 @@ function temporalFindCyclesSelect(prepared, direction, temporal, typedEdgeId, ed
           ELSE [${edgeFromKey}, ${edgeToKey}]
         END,
         [${q("edges")}.${q("__event_id")}], [${edgeIdentityKey}],
-        [${step(edgeCost)}]::${stepType}[], ${edgeCost},
+        [${step(edgeCost, firstAnchor)}]::${stepType}[], ${edgeCost},
         ${edgeFromKey} = ${edgeToKey},
         ${q("edges")}.${q("__event_id")},
         ${q("edges")}.${q("__event_start")},
-        ${q("edges")}.${q("__event_end")}
+        ${q("edges")}.${q("__event_end")}${elapsedTime ? `, ${firstAnchor}` : ""}
       FROM ${edgesRelation} AS ${q("edges")}
       INNER JOIN ${startsRelation} AS ${q("starts")}
         ON ${q("starts")}.${q("__start_key")} = ${edgeFromKey}
@@ -295,12 +302,12 @@ function temporalFindCyclesSelect(prepared, direction, temporal, typedEdgeId, ed
         list_append(${q("walks")}.${q("__event_ids")},
           ${q("edges")}.${q("__event_id")}),
         list_append(${q("walks")}.${q("__edge_keys")}, ${edgeIdentityKey}),
-        list_append(${q("walks")}.${q("steps")}, ${step(candidateDistance)}),
+        list_append(${q("walks")}.${q("steps")}, ${step(candidateDistance, anchor)}),
         ${candidateDistance},
         ${edgeToKey} = ${q("walks")}.${q("__start_key")},
         ${q("edges")}.${q("__event_id")},
         ${q("edges")}.${q("__event_start")},
-        ${q("edges")}.${q("__event_end")}
+        ${q("edges")}.${q("__event_end")}${elapsedTime ? `, ${anchor}` : ""}
       FROM ${walksRelation} AS ${q("walks")}
       INNER JOIN ${edgesRelation} AS ${q("edges")}
         ON ${q("walks")}.${q("__node_key")} = ${edgeFromKey}
@@ -326,5 +333,5 @@ function temporalFindCyclesSelect(prepared, direction, temporal, typedEdgeId, ed
           AS BIGINT) AS ${q("pathId")}, ${q("steps")}
       FROM ${completeRelation}
     )
-    ${graphRouteResultSelect(rankedRelation, input, edgeIdColumn, true)}`;
+    ${graphRouteResultSelect(rankedRelation, input, edgeIdColumn, true, elapsedTime)}`;
 }

package/esm/methods/paths.d.ts

@@ -3,6 +3,7 @@ import type { GraphId } from "../helpers/prepareGraphStarts.js";
 import { type GraphTemporalOptions } from "../helpers/prepareGraphTemporalSql.js";
 import type { GraphDirection } from "../helpers/prepareGraphTraversal.js";
 type PathsOptions = GraphTemporalOptions & {
+    elapsedTime?: boolean;
     direction?: GraphDirection;
     outputTable?: string | boolean;
     weight?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/methods/paths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AASvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAgC,EAC9B,KAAK,oBAAoB,EAG1B,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAM1E,KAAK,YAAY,GAAG,oBAAoB,GAAG;IACzC,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,KAAK,CAC3B,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,YAAiB,GACzB,WAAW,CA+Gb"}
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/methods/paths.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AASvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAgC,EAC9B,KAAK,oBAAoB,EAG1B,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAM1E,KAAK,YAAY,GAAG,oBAAoB,GAAG;IACzC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,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,KAAK,CAC3B,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,YAAiB,GACzB,WAAW,CA4Hb"}

package/esm/methods/paths.js

@@ -1,3 +1,4 @@
+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";
@@ -30,6 +31,7 @@ export default function paths(simpleTable, sourceColumn, targetColumn, edgeId, s
         typeof options.outputTable !== "boolean") {
         throw new TypeError("paths() options.outputTable must be a string or boolean.");
     }
+    const metric = prepareGraphMetricOptions(options, "paths()", false);
     const endpoints = prepareGraphRouteEndpoints(start, end, "paths()");
     const direction = options.direction ?? "outgoing";
     const temporalOptions = prepareGraphTemporalOptions(options, direction, "paths()");
@@ -50,7 +52,8 @@ export default function paths(simpleTable, sourceColumn, targetColumn, edgeId, s
             ? undefined
             : (input) => validateGraphTemporalEvents(input, temporalOptions, "paths()", parameters),
         values: (schema) => {
-            validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "paths()");
+            const validated = validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "paths()");
+            graphRouteResultSchema(schema, validated.distanceType, "paths()", metric.elapsedTime);
             const temporal = temporalOptions === undefined
                 ? undefined
                 : prepareGraphTemporalSql(schema, temporalOptions, "paths()");
@@ -58,22 +61,22 @@ export default function paths(simpleTable, sourceColumn, targetColumn, edgeId, s
                 ? endpoints.values.values
                 : [temporal.gapParameter, ...endpoints.values.values];
         },
-        buildSelect: (input, schema) => pathsSelect(input, schema, sourceColumn, targetColumn, edgeId, endpoints, direction, options.weight, temporalOptions),
+        buildSelect: (input, schema) => pathsSelect(input, schema, sourceColumn, targetColumn, edgeId, endpoints, direction, options.weight, temporalOptions, metric.elapsedTime),
         outputSchema: (schema) => {
             const validated = validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "paths()");
             if (temporalOptions !== undefined) {
                 prepareGraphTemporalSql(schema, temporalOptions, "paths()");
             }
-            return graphRouteResultSchema(schema, validated.distanceType, "paths()");
+            return graphRouteResultSchema(schema, validated.distanceType, "paths()", metric.elapsedTime);
         },
     });
 }
-function pathsSelect(input, schema, source, target, edgeId, routeEndpoints, direction, weight, temporalOptions) {
+function pathsSelect(input, schema, source, target, edgeId, routeEndpoints, direction, weight, temporalOptions, elapsedTime) {
     const route = prepareGraphRouteSql(input, schema, source, target, edgeId, routeEndpoints, weight, "paths()");
     const prepared = route.traversal;
     if (temporalOptions !== undefined) {
         const temporal = prepareGraphTemporalSql(schema, temporalOptions, "paths()");
-        return temporalPathsSelect(route, direction, temporal);
+        return temporalPathsSelect(route, direction, temporal, elapsedTime);
     }
     const distanceType = route.distanceType;
     const q = quoteIdentifier;
@@ -166,7 +169,7 @@ function pathsSelect(input, schema, source, target, edgeId, routeEndpoints, dire
     )
     ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn)}`;
 }
-function temporalPathsSelect(route, direction, temporal) {
+function temporalPathsSelect(route, direction, temporal, elapsedTime) {
     const prepared = route.traversal;
     const distanceType = route.distanceType;
     const q = quoteIdentifier;
@@ -197,12 +200,16 @@ function temporalPathsSelect(route, direction, temporal) {
     const edgeKey = `${q("edges")}.${q("__edge_key")}`;
     const candidateDistance = `CAST(${q("routes")}.${q("distance")} + ${edgeCost} AS ${distanceType})`;
     const gap = `${q("settings")}.${q("__gap")}`;
-    const step = (distance) => `struct_pack(
+    const firstAnchor = temporal.journeyAnchor("edges", direction);
+    const anchor = `${q("routes")}.${q("__journey_anchor")}`;
+    const step = (distance, journeyAnchor) => `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}${elapsedTime
+        ? `, ${q("elapsedTimeMs")} := ${temporal.elapsedMilliseconds(temporal.journeyElapsed("edges", journeyAnchor, direction))}`
+        : ""}
         )`;
     return `WITH RECURSIVE ${settingsRelation} AS MATERIALIZED (
       SELECT CAST(? AS HUGEINT) AS ${q("__gap")}
@@ -241,14 +248,14 @@ function temporalPathsSelect(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")}${elapsedTime ? `, ${q("__journey_anchor")}` : ""}
     ) AS (
       SELECT ${edgeTo}, ${edgeToKey},
         [${q("__start_key")}, ${edgeToKey}], [${edgeKey}],
-        [${step(edgeCost)}], ${edgeCost},
+        [${step(edgeCost, firstAnchor)}], ${edgeCost},
         ${q("edges")}.${q("__event_id")},
         ${q("edges")}.${q("__event_start")},
-        ${q("edges")}.${q("__event_end")}
+        ${q("edges")}.${q("__event_end")}${elapsedTime ? `, ${firstAnchor}` : ""}
       FROM ${endpointRelation}
       INNER JOIN ${edgesRelation} AS ${q("edges")}
         ON ${q("__start_key")} = ${edgeFromKey}
@@ -259,10 +266,10 @@ function temporalPathsSelect(route, direction, temporal) {
       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, anchor)}),
         ${candidateDistance}, ${q("edges")}.${q("__event_id")},
         ${q("edges")}.${q("__event_start")},
-        ${q("edges")}.${q("__event_end")}
+        ${q("edges")}.${q("__event_end")}${elapsedTime ? `, ${anchor}` : ""}
       FROM ${routesRelation} AS ${q("routes")}
       INNER JOIN ${edgesRelation} AS ${q("edges")}
         ON ${q("routes")}.${q("__node_key")} = ${edgeFromKey}
@@ -283,5 +290,5 @@ function temporalPathsSelect(route, direction, temporal) {
           AS ${q("pathId")}, ${q("steps")}
       FROM ${completeRelation}
     )
-    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn)}`;
+    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn, false, elapsedTime)}`;
 }

package/esm/methods/shortestPath.d.ts

@@ -6,6 +6,8 @@ type ShortestPathOptions = GraphTemporalOptions & {
     direction?: GraphDirection;
     outputTable?: string | boolean;
     weight?: string;
+    elapsedTime?: boolean;
+    minimize?: "weight" | "elapsedTime";
 };
 export default function shortestPath(simpleTable: SimpleTable, sourceColumn: string, targetColumn: string, edgeId: string, start: GraphId, end: GraphId, options?: ShortestPathOptions): SimpleTable;
 export {};

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

@@ -1 +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"}
+{"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,QAAQ,GAAG,aAAa,CAAC;CACrC,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,CAsHb"}