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

package/esm/methods/shortestPath.js

@@ -53,7 +53,7 @@ export default function shortestPath(simpleTable, sourceColumn, targetColumn, ed
             ? undefined
             : (input) => validateGraphTemporalEvents(input, temporalOptions, "shortestPath()", parameters),
         values: (schema) => {
-            validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "shortestPath()");
+            validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "shortestPath()", options.weight !== undefined);
             const temporal = temporalOptions === undefined
                 ? undefined
                 : prepareGraphTemporalSql(schema, temporalOptions, "shortestPath()");
@@ -63,27 +63,28 @@ export default function shortestPath(simpleTable, sourceColumn, targetColumn, ed
         },
         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()");
+            const validated = validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "shortestPath()", options.weight !== undefined);
             if (temporalOptions !== undefined) {
                 prepareGraphTemporalSql(schema, temporalOptions, "shortestPath()");
             }
-            return graphRouteResultSchema(schema, validated.distanceType, "shortestPath()", metrics.elapsedTime);
+            return graphRouteResultSchema(schema, validated.distanceType, "shortestPath()", metrics.elapsedTime, options.weight !== undefined);
         },
     });
 }
 function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoints, direction, weight, temporalOptions, metrics) {
-    const route = prepareGraphRouteSql(input, schema, source, target, edgeId, routeEndpoints, weight, "shortestPath()");
+    const route = prepareGraphRouteSql(input, schema, source, target, edgeId, routeEndpoints, weight, "shortestPath()", weight !== undefined);
     const prepared = route.traversal;
     if (temporalOptions !== undefined) {
         const temporal = prepareGraphTemporalSql(schema, temporalOptions, "shortestPath()");
-        return temporalShortestPathSelect(route, direction, temporal, metrics);
+        return temporalShortestPathSelect(route, direction, temporal, metrics, weight !== undefined);
     }
     const distanceType = route.distanceType;
     // Exact shortest routes have optimal prefixes. Floating addition can erase
     // a prefix-cost difference later, so retain all simple prefixes up to the
     // best complete cost before selecting the full-route ties.
-    const floating = route.weightType === "FLOAT" ||
-        route.weightType === "DOUBLE";
+    const floating = metrics.minimize === "weight" &&
+        (route.weightType === "FLOAT" || route.weightType === "DOUBLE");
+    const metricType = metrics.minimize === "steps" ? "BIGINT" : distanceType;
     const relations = prepared.relationNames([
         "graph_route_endpoints",
         "graph_edges",
@@ -109,8 +110,17 @@ function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoint
     const edgeToKey = `${q("edges")}.${q("__to_key")}`;
     const edgeTo = `${q("edges")}.${q("__to")}`;
     const edgeCost = `${q("edges")}.${q("__weight")}`;
+    const edgeMetric = metrics.minimize === "steps"
+        ? "CAST(1 AS BIGINT)"
+        : edgeCost;
     const routeDistance = `${q("routes")}.${q("distance")}`;
     const candidateDistance = `CAST(${routeDistance} + ${edgeCost} AS ${distanceType})`;
+    const routeMetric = metrics.minimize === "steps"
+        ? `len(${q("routes")}.${q("steps")})`
+        : routeDistance;
+    const candidateMetric = metrics.minimize === "steps"
+        ? `${routeMetric} + 1`
+        : candidateDistance;
     return `WITH RECURSIVE ${endpointRelation}(
       ${q("start")}, ${q("end")}, ${q("__start_key")}, ${q("__end_key")}
     ) AS (
@@ -142,13 +152,13 @@ function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoint
       ${q("node")}, ${q("__node_key")}, ${q("distance")}
     ) USING KEY(${q("__node_key")}) AS (
       SELECT ${q("start")}, ${q("__start_key")},
-        CAST(0 AS ${distanceType})
+        CAST(0 AS ${metricType})
       FROM ${endpointRelation}
       INNER JOIN ${toEndRelation}
         ON ${q("__start_key")} = ${q("__key")}
       UNION
       SELECT ${edgeTo}, ${edgeToKey},
-        MIN(CAST(${q("reached")}.${q("distance")} + ${edgeCost} AS ${distanceType}))
+        MIN(CAST(${q("reached")}.${q("distance")} + ${edgeMetric} AS ${metricType}))
       FROM ${distancesRelation} AS ${q("reached")}
       INNER JOIN ${edgesRelation} AS ${q("edges")}
         ON ${q("reached")}.${q("__node_key")} = ${edgeFromKey}
@@ -158,7 +168,7 @@ function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoint
         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")}
+        OR MIN(CAST(${q("reached")}.${q("distance")} + ${edgeMetric} AS ${metricType})) < ${q("best")}.${q("distance")}
     ), ${bestTotalRelation} AS (
       SELECT ${q("distances")}.${q("distance")}
       FROM ${distancesRelation} AS ${q("distances")}
@@ -197,23 +207,23 @@ function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoint
       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")}`}
+        ? `${candidateMetric} <= ${q("best_total")}.${q("distance")}`
+        : `${candidateMetric} = ${q("best_prefix")}.${q("distance")}`}
     ), ${shortestRelation} AS (
       SELECT ${q("__edge_keys")}, ${q("steps")}
-      FROM ${routesRelation}
+      FROM ${routesRelation} AS ${q("routes")}
       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")}
+        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, false, weight !== undefined)}`;
 }
-function temporalShortestPathSelect(route, direction, temporal, metrics) {
+function temporalShortestPathSelect(route, direction, temporal, metrics, includeTotal) {
     const prepared = route.traversal;
     const q = quoteIdentifier;
     const startsSelect = `SELECT ${q("start")},
@@ -226,7 +236,7 @@ function temporalShortestPathSelect(route, direction, temporal, metrics) {
         : buildGraphTemporalCostStateSql(prepared, startsSelect, direction, temporal, route.distanceType, route.edgeWeight, [
             `${route.typedEdgeId} AS ${q("__edge_id")}`,
             `${route.edgeKey} AS ${q("__edge_key")}`,
-        ]);
+        ], metrics.minimize === "steps" ? "steps" : "weight");
     const relations = prepared.relationNames([
         "graph_route_endpoints",
         "graph_nodes",
@@ -256,15 +266,21 @@ function temporalShortestPathSelect(route, direction, temporal, metrics) {
     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 firstMetric = metrics.minimize === "steps"
+        ? "1"
+        : metrics.minimize === "elapsedTime"
+            ? firstElapsed
+            : edgeCost;
+    const routeMetric = metrics.minimize === "steps"
+        ? `len(${q("routes")}.${q("steps")})`
+        : metrics.minimize === "elapsedTime"
+            ? `${q("routes")}.${q("__elapsed")}`
+            : routeDistance;
+    const candidateMetric = metrics.minimize === "steps"
+        ? `${routeMetric} + 1`
+        : metrics.minimize === "elapsedTime"
+            ? candidateElapsed
+            : candidateDistance;
     const step = (distance, elapsed) => `struct_pack(
           ${q("edgeId")} := ${q("edges")}.${q("__edge_id")},
           ${q("source")} := ${q("edges")}.${q("__from")},
@@ -297,7 +313,7 @@ function temporalShortestPathSelect(route, direction, temporal, metrics) {
       INNER JOIN ${edgesRelation} AS ${q("edges")}
         ON ${q("reached")}.${q("__key")} = ${edgeToKey}
     ), ${bestTotalRelation} AS (
-      SELECT MIN(${q("costs")}.${q("distance")}) AS ${q("distance")}
+      SELECT MIN(${q("costs")}.${q(metrics.minimize === "steps" ? "steps" : "distance")}) AS ${q("distance")}
       FROM ${costs.costRelation} AS ${q("costs")}
       INNER JOIN ${endpointRelation}
         ON ${q("costs")}.${q("__node_key")} = ${q("__end_key")}
@@ -352,7 +368,7 @@ function temporalShortestPathSelect(route, direction, temporal, metrics) {
           AS ${q("pathId")}, ${q("steps")}
       FROM ${shortestRelation}
     )
-    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn, false, metrics.elapsedTime)}`;
+    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn, false, metrics.elapsedTime, includeTotal)}`;
 }
 // At the same physical event a later departure (or earlier incoming arrival)
 // dominates every future elapsed duration. Keyed improvements find the optimum

package/esm/methods/similarityMahalanobis.js

@@ -44,11 +44,11 @@ export default function similarityMahalanobis(table, columns, referencePoint, ne
 }
 async function execute(table, columns, referencePoint, newColumn, options) {
     const sourceColumns = Object.keys(await table.getTypes());
-    const scoreColumn = options.similarityScoreColumn === true
+    const scoreColumn = options.similarityColumn === true
         ? "similarity"
-        : options.similarityScoreColumn === false
+        : options.similarityColumn === false
             ? undefined
-            : options.similarityScoreColumn;
+            : options.similarityColumn;
     const outputNames = scoreColumn === undefined
         ? [newColumn]
         : [newColumn, scoreColumn];