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

package/esm/methods/distances.js

@@ -0,0 +1,164 @@
+import buildGraphTemporalCostStateSql from "../helpers/buildGraphTemporalCostStateSql.js";
+import getGraphWeightColumn from "../helpers/getGraphWeightColumn.js";
+import prepareGraphTemporalSql, { prepareGraphTemporalOptions, } from "../helpers/prepareGraphTemporalSql.js";
+import prepareGraphStarts from "../helpers/prepareGraphStarts.js";
+import prepareGraphTraversal, { validateGraphStarts, } from "../helpers/prepareGraphTraversal.js";
+import queueGraphResult from "../helpers/queueGraphResult.js";
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import validateGraphTemporalEvents from "../helpers/validateGraphTemporalEvents.js";
+export default function distances(simpleTable, sourceColumn, targetColumn, startNodes, options = {}) {
+    if (typeof sourceColumn !== "string") {
+        throw new TypeError("distances() sourceColumn must be a string.");
+    }
+    if (typeof targetColumn !== "string") {
+        throw new TypeError("distances() targetColumn must be a string.");
+    }
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+        throw new TypeError("distances() options must be an object.");
+    }
+    if (options.direction !== undefined &&
+        !["outgoing", "incoming", "both"].includes(options.direction)) {
+        throw new TypeError('distances() options.direction must be "outgoing", "incoming", or "both".');
+    }
+    if (options.weight !== undefined && typeof options.weight !== "string") {
+        throw new TypeError("distances() options.weight must be a string.");
+    }
+    if (options.outputTable !== undefined &&
+        typeof options.outputTable !== "string" &&
+        typeof options.outputTable !== "boolean") {
+        throw new TypeError("distances() options.outputTable must be a string or boolean.");
+    }
+    const preparedStarts = prepareGraphStarts(startNodes, "distances()", "startNodes");
+    const direction = options.direction ?? "outgoing";
+    const temporalOptions = prepareGraphTemporalOptions(options, direction, "distances()");
+    options = structuredClone(options);
+    const parameters = {
+        sourceColumn,
+        targetColumn,
+        startNodes: structuredClone(startNodes),
+        options,
+    };
+    return queueGraphResult(simpleTable, {
+        method: "distances()",
+        parameters,
+        outputTable: options.outputTable,
+        preflight: temporalOptions === undefined
+            ? undefined
+            : (input) => validateGraphTemporalEvents(input, temporalOptions, "distances()", parameters),
+        values: (schema) => {
+            const { temporal } = validateDistanceInputs(schema, sourceColumn, targetColumn, preparedStarts, options.weight, temporalOptions);
+            return temporal === undefined
+                ? preparedStarts.values
+                : [temporal.gapParameter, ...preparedStarts.values];
+        },
+        buildSelect: (input, schema) => distancesSelect(input, schema, sourceColumn, targetColumn, preparedStarts, direction, options.weight, temporalOptions),
+        outputSchema: (schema) => {
+            const validated = validateDistanceInputs(schema, sourceColumn, targetColumn, preparedStarts, options.weight, temporalOptions);
+            return {
+                start: validated.idType,
+                node: validated.idType,
+                distance: validated.distanceType,
+            };
+        },
+    });
+}
+function validateDistanceInputs(schema, source, target, starts, weight, temporalOptions) {
+    const endpoints = validateGraphStarts(schema, source, target, starts, "distances()", "startNodes");
+    const distanceType = weight === undefined
+        ? "BIGINT"
+        : getGraphWeightColumn(schema, weight, "distances()").distanceType;
+    const temporal = temporalOptions === undefined
+        ? undefined
+        : prepareGraphTemporalSql(schema, temporalOptions, "distances()");
+    return { idType: endpoints.idType, distanceType, temporal };
+}
+function distancesSelect(input, schema, source, target, starts, direction, weight, temporalOptions) {
+    const prepared = prepareGraphTraversal(input, schema, source, target, starts, "distances()", "startNodes");
+    const weightColumn = weight === undefined
+        ? undefined
+        : getGraphWeightColumn(schema, weight, "distances()");
+    const distanceType = weightColumn?.distanceType ?? "BIGINT";
+    const edgeWeight = weightColumn === undefined
+        ? `CAST(1 AS ${distanceType})`
+        : `CAST(${quoteIdentifier("edges")}.${quoteIdentifier(weightColumn.column)} AS ${distanceType})`;
+    if (temporalOptions !== undefined) {
+        const temporal = prepareGraphTemporalSql(schema, temporalOptions, "distances()");
+        return temporalDistancesSelect(prepared, direction, temporal, distanceType, edgeWeight);
+    }
+    const relations = prepared.relationNames([
+        "graph_start_values",
+        "graph_starts",
+        "graph_edges",
+        "graph_distances",
+    ]);
+    const startValuesRelation = relations.graph_start_values;
+    const startsRelation = relations.graph_starts;
+    const edgesRelation = relations.graph_edges;
+    const distancesRelation = relations.graph_distances;
+    const start = `${quoteIdentifier("starts")}.${quoteIdentifier("start")}`;
+    const startKey = `${quoteIdentifier("starts")}.${quoteIdentifier("__key")}`;
+    const reachedStart = `${quoteIdentifier("reached")}.${quoteIdentifier("start")}`;
+    const reachedStartKey = `${quoteIdentifier("reached")}.${quoteIdentifier("__start_key")}`;
+    const reachedNodeKey = `${quoteIdentifier("reached")}.${quoteIdentifier("__node_key")}`;
+    const reachedDistance = `${quoteIdentifier("reached")}.${quoteIdentifier("distance")}`;
+    const edgeTo = `${quoteIdentifier("edges")}.${quoteIdentifier("__to")}`;
+    const edgeToKey = `${quoteIdentifier("edges")}.${quoteIdentifier("__to_key")}`;
+    const edgeFromKey = `${quoteIdentifier("edges")}.${quoteIdentifier("__from_key")}`;
+    const edgeCost = `${quoteIdentifier("edges")}.${quoteIdentifier("__weight")}`;
+    const bestDistance = `${quoteIdentifier("best")}.${quoteIdentifier("distance")}`;
+    const candidateDistance = `CAST(${reachedDistance} + ${edgeCost} AS ${distanceType})`;
+    return `WITH RECURSIVE ${startValuesRelation}(${quoteIdentifier("start")}) AS (
+      VALUES ${prepared.startValues}
+    ), ${startsRelation} AS (
+      SELECT ${quoteIdentifier("start")},
+        ${prepared.key(quoteIdentifier("start"))} AS ${quoteIdentifier("__key")}
+      FROM ${startValuesRelation}
+    ), ${edgesRelation} AS (
+      ${prepared.edges(direction, [
+        `${edgeWeight} AS ${quoteIdentifier("__weight")}`,
+    ])}
+    ), ${distancesRelation}(
+      ${quoteIdentifier("start")}, ${quoteIdentifier("node")},
+      ${quoteIdentifier("__start_key")}, ${quoteIdentifier("__node_key")},
+      ${quoteIdentifier("distance")}
+    ) USING KEY(
+      ${quoteIdentifier("__start_key")}, ${quoteIdentifier("__node_key")}
+    ) AS (
+      SELECT ${start}, ${edgeTo}, ${startKey}, ${edgeToKey},
+        MIN(${edgeCost}) AS ${quoteIdentifier("distance")}
+      FROM ${startsRelation} AS ${quoteIdentifier("starts")}
+      INNER JOIN ${edgesRelation} AS ${quoteIdentifier("edges")}
+        ON ${startKey} = ${edgeFromKey}
+      GROUP BY ${start}, ${edgeTo}, ${startKey}, ${edgeToKey}
+      UNION
+      SELECT ${reachedStart}, ${edgeTo}, ${reachedStartKey}, ${edgeToKey},
+        MIN(${candidateDistance}) AS ${quoteIdentifier("distance")}
+      FROM ${distancesRelation} AS ${quoteIdentifier("reached")}
+      INNER JOIN ${edgesRelation} AS ${quoteIdentifier("edges")}
+        ON ${reachedNodeKey} = ${edgeFromKey}
+      LEFT JOIN recurring.${distancesRelation} AS ${quoteIdentifier("best")}
+        ON ${reachedStartKey} = ${quoteIdentifier("best")}.${quoteIdentifier("__start_key")}
+        AND ${edgeToKey} = ${quoteIdentifier("best")}.${quoteIdentifier("__node_key")}
+      GROUP BY ${reachedStart}, ${edgeTo}, ${reachedStartKey}, ${edgeToKey},
+        ${bestDistance}
+      HAVING ${bestDistance} IS NULL OR MIN(${candidateDistance}) < ${bestDistance}
+    )
+    SELECT ${quoteIdentifier("start")}, ${quoteIdentifier("node")},
+      ${quoteIdentifier("distance")}
+    FROM ${distancesRelation}
+    ORDER BY ${quoteIdentifier("__start_key")}, ${quoteIdentifier("distance")}, ${quoteIdentifier("__node_key")}`;
+}
+function temporalDistancesSelect(prepared, direction, temporal, distanceType, edgeWeight) {
+    const q = quoteIdentifier;
+    const startsSelect = `SELECT ${q("start")},
+        ${prepared.key(q("start"))} AS ${q("__key")}
+      FROM (VALUES ${prepared.startValues}) AS ${q("start_values")}(${q("start")})`;
+    const costStates = buildGraphTemporalCostStateSql(prepared, startsSelect, direction, temporal, distanceType, edgeWeight);
+    return `${costStates.withClause}
+    SELECT ${q("start")}, ${q("node")},
+      MIN(${q("distance")}) AS ${q("distance")}
+    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")}`;
+}

package/esm/methods/findCycles.d.ts

@@ -0,0 +1,12 @@
+import type SimpleTable from "../class/SimpleTable.js";
+import { type GraphTemporalOptions } from "../helpers/prepareGraphTemporalSql.js";
+import { type GraphId } from "../helpers/prepareGraphStarts.js";
+import { type GraphDirection } from "../helpers/prepareGraphTraversal.js";
+type FindCyclesOptions = GraphTemporalOptions & {
+    direction?: GraphDirection;
+    outputTable?: string | boolean;
+    weight?: string;
+};
+export default function findCycles(simpleTable: SimpleTable, sourceColumn: string, targetColumn: string, edgeId: string, startNodes: GraphId | GraphId[], options?: FindCyclesOptions): SimpleTable;
+export {};
+//# sourceMappingURL=findCycles.d.ts.map

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

@@ -0,0 +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"}

package/esm/methods/findCycles.js

@@ -0,0 +1,330 @@
+import getGraphEdgeIdColumn from "../helpers/getGraphEdgeIdColumn.js";
+import getGraphWeightColumn from "../helpers/getGraphWeightColumn.js";
+import graphRouteResultSchema from "../helpers/graphRouteResultSchema.js";
+import graphRouteResultSelect from "../helpers/graphRouteResultSelect.js";
+import prepareGraphTemporalSql, { prepareGraphTemporalOptions, } from "../helpers/prepareGraphTemporalSql.js";
+import prepareGraphStarts from "../helpers/prepareGraphStarts.js";
+import prepareGraphTraversal, { validateGraphStarts, } from "../helpers/prepareGraphTraversal.js";
+import queueGraphResult from "../helpers/queueGraphResult.js";
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import validateGraphTemporalEvents from "../helpers/validateGraphTemporalEvents.js";
+import validateGraphRouteResultSchema from "../helpers/validateGraphRouteResultSchema.js";
+export default function findCycles(simpleTable, sourceColumn, targetColumn, edgeId, startNodes, options = {}) {
+    if (typeof sourceColumn !== "string") {
+        throw new TypeError("findCycles() sourceColumn must be a string.");
+    }
+    if (typeof targetColumn !== "string") {
+        throw new TypeError("findCycles() targetColumn must be a string.");
+    }
+    if (typeof edgeId !== "string") {
+        throw new TypeError("findCycles() edgeId must be a string.");
+    }
+    const preparedStarts = prepareGraphStarts(startNodes, "findCycles()", "startNodes");
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+        throw new TypeError("findCycles() options must be an object.");
+    }
+    if (options.direction !== undefined &&
+        !["outgoing", "incoming", "both"].includes(options.direction)) {
+        throw new TypeError('findCycles() options.direction must be "outgoing", "incoming", or "both".');
+    }
+    if (options.weight !== undefined && typeof options.weight !== "string") {
+        throw new TypeError("findCycles() options.weight must be a string.");
+    }
+    if (options.outputTable !== undefined &&
+        typeof options.outputTable !== "string" &&
+        typeof options.outputTable !== "boolean") {
+        throw new TypeError("findCycles() options.outputTable must be a string or boolean.");
+    }
+    const direction = options.direction ?? "outgoing";
+    const temporalOptions = prepareGraphTemporalOptions(options, direction, "findCycles()");
+    options = structuredClone(options);
+    const parameters = {
+        sourceColumn,
+        targetColumn,
+        edgeId,
+        startNodes: structuredClone(startNodes),
+        options,
+    };
+    return queueGraphResult(simpleTable, {
+        method: "findCycles()",
+        parameters,
+        outputTable: options.outputTable,
+        preflight: temporalOptions === undefined
+            ? undefined
+            : (input) => validateGraphTemporalEvents(input, temporalOptions, "findCycles()", parameters),
+        values: (schema) => {
+            validateFindCyclesInputs(schema, sourceColumn, targetColumn, edgeId, preparedStarts, options.weight);
+            const temporal = temporalOptions === undefined
+                ? undefined
+                : prepareGraphTemporalSql(schema, temporalOptions, "findCycles()");
+            return temporal === undefined
+                ? preparedStarts.values
+                : [temporal.gapParameter, ...preparedStarts.values];
+        },
+        buildSelect: (input, schema) => findCyclesSelect(input, schema, sourceColumn, targetColumn, edgeId, preparedStarts, direction, options.weight, temporalOptions),
+        outputSchema: (schema) => {
+            const validated = validateFindCyclesInputs(schema, sourceColumn, targetColumn, edgeId, preparedStarts, options.weight);
+            if (temporalOptions !== undefined) {
+                prepareGraphTemporalSql(schema, temporalOptions, "findCycles()");
+            }
+            return {
+                start: validated.nodeIdType,
+                ...graphRouteResultSchema(schema, validated.distanceType, "findCycles()"),
+            };
+        },
+    });
+}
+function validateFindCyclesInputs(schema, source, target, edgeId, starts, weight) {
+    const endpoints = validateGraphStarts(schema, source, target, starts, "findCycles()", "startNodes");
+    const edgeIdColumn = getGraphEdgeIdColumn(schema, edgeId, "findCycles()");
+    const weightColumn = weight === undefined
+        ? undefined
+        : getGraphWeightColumn(schema, weight, "findCycles()");
+    validateGraphRouteResultSchema(schema, "findCycles()", ["start"]);
+    return {
+        distanceType: weightColumn?.distanceType ?? "BIGINT",
+        edgeIdType: edgeIdColumn.idType,
+        nodeIdType: endpoints.idType,
+    };
+}
+function findCyclesSelect(input, schema, source, target, edgeId, starts, direction, weight, temporalOptions) {
+    const prepared = prepareGraphTraversal(input, schema, source, target, starts, "findCycles()", "startNodes");
+    const edgeIdColumn = getGraphEdgeIdColumn(schema, edgeId, "findCycles()");
+    const weightColumn = weight === undefined
+        ? undefined
+        : getGraphWeightColumn(schema, weight, "findCycles()");
+    const distanceType = weightColumn?.distanceType ?? "BIGINT";
+    const q = quoteIdentifier;
+    const edgeIdReference = `${q("edges")}.${q(edgeIdColumn.column)}`;
+    const typedEdgeId = `CAST(${edgeIdReference} AS ${edgeIdColumn.idType})`;
+    const edgeKey = edgeIdColumn.family === "string"
+        ? `ENCODE(${typedEdgeId})`
+        : typedEdgeId;
+    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})`;
+    if (temporalOptions !== undefined) {
+        const temporal = prepareGraphTemporalSql(schema, temporalOptions, "findCycles()");
+        return temporalFindCyclesSelect(prepared, direction, temporal, typedEdgeId, edgeKey, edgeWeight, distanceType, stepType, input, edgeIdColumn);
+    }
+    const relations = prepared.relationNames([
+        "graph_start_values",
+        "graph_starts",
+        "graph_edges",
+        "graph_cycle_walks",
+        "graph_complete_cycles",
+        "graph_ranked_cycles",
+    ]);
+    const startValuesRelation = relations.graph_start_values;
+    const startsRelation = relations.graph_starts;
+    const edgesRelation = relations.graph_edges;
+    const walksRelation = relations.graph_cycle_walks;
+    const completeRelation = relations.graph_complete_cycles;
+    const rankedRelation = relations.graph_ranked_cycles;
+    const edgeFrom = `${q("edges")}.${q("__from")}`;
+    const edgeTo = `${q("edges")}.${q("__to")}`;
+    const edgeFromKey = `${q("edges")}.${q("__from_key")}`;
+    const edgeToKey = `${q("edges")}.${q("__to_key")}`;
+    const edgeIdentity = `${q("edges")}.${q("__edge_id")}`;
+    const edgeIdentityKey = `${q("edges")}.${q("__edge_key")}`;
+    const edgeCost = `${q("edges")}.${q("__weight")}`;
+    const walkDistance = `${q("walks")}.${q("distance")}`;
+    const candidateDistance = `CAST(${walkDistance} + ${edgeCost} AS ${distanceType})`;
+    return `WITH RECURSIVE ${startValuesRelation}(${q("start")}) AS (
+      VALUES ${prepared.startValues}
+    ), ${startsRelation} AS (
+      SELECT ${q("start")},
+        ${prepared.key(q("start"))} AS ${q("__start_key")}
+      FROM ${startValuesRelation}
+    ), ${edgesRelation} AS (
+      ${prepared.edges(direction, [
+        `${typedEdgeId} AS ${q("__edge_id")}`,
+        `${edgeKey} AS ${q("__edge_key")}`,
+        `${edgeWeight} AS ${q("__weight")}`,
+    ])}
+    ), ${walksRelation}(
+      ${q("start")}, ${q("__start_key")}, ${q("node")},
+      ${q("__node_key")}, ${q("__visited")}, ${q("__edge_keys")},
+      ${q("steps")}, ${q("distance")}, ${q("closed")}
+    ) AS (
+      SELECT ${q("starts")}.${q("start")},
+        ${q("starts")}.${q("__start_key")}, ${edgeTo}, ${edgeToKey},
+        CASE WHEN ${edgeFromKey} = ${edgeToKey}
+          THEN [${edgeFromKey}]
+          ELSE [${edgeFromKey}, ${edgeToKey}]
+        END,
+        [${edgeIdentityKey}],
+        [struct_pack(
+          ${q("edgeId")} := ${edgeIdentity},
+          ${q("source")} := ${edgeFrom},
+          ${q("target")} := ${edgeTo},
+          ${q("weight")} := ${edgeCost},
+          ${q("distance")} := ${edgeCost}
+        )]::${stepType}[],
+        ${edgeCost}, ${edgeFromKey} = ${edgeToKey}
+      FROM ${edgesRelation} AS ${q("edges")}
+      INNER JOIN ${startsRelation} AS ${q("starts")}
+        ON ${q("starts")}.${q("__start_key")} = ${edgeFromKey}
+      UNION ALL
+      SELECT ${q("walks")}.${q("start")},
+        ${q("walks")}.${q("__start_key")}, ${edgeTo}, ${edgeToKey},
+        list_append(${q("walks")}.${q("__visited")}, ${edgeToKey}),
+        list_append(${q("walks")}.${q("__edge_keys")}, ${edgeIdentityKey}),
+        list_append(${q("walks")}.${q("steps")}, struct_pack(
+          ${q("edgeId")} := ${edgeIdentity},
+          ${q("source")} := ${edgeFrom},
+          ${q("target")} := ${edgeTo},
+          ${q("weight")} := ${edgeCost},
+          ${q("distance")} := ${candidateDistance}
+        )), ${candidateDistance},
+        ${edgeToKey} = ${q("walks")}.${q("__start_key")}
+      FROM ${walksRelation} AS ${q("walks")}
+      INNER JOIN ${edgesRelation} AS ${q("edges")}
+        ON ${q("walks")}.${q("__node_key")} = ${edgeFromKey}
+      WHERE NOT ${q("walks")}.${q("closed")}
+        AND NOT list_contains(
+          ${q("walks")}.${q("__edge_keys")}, ${edgeIdentityKey}
+        )
+        AND (
+          ${edgeToKey} = ${q("walks")}.${q("__start_key")}
+          OR NOT list_contains(
+            ${q("walks")}.${q("__visited")}, ${edgeToKey}
+          )
+        )
+    ), ${completeRelation} AS (
+      SELECT DISTINCT ${q("start")}, ${q("__start_key")},
+        ${q("__edge_keys")}, ${q("steps")}
+      FROM ${walksRelation}
+      WHERE ${q("closed")}${direction === "both"
+        ? `
+        AND ${q("__edge_keys")} <= list_reverse(${q("__edge_keys")})`
+        : ""}
+    ), ${rankedRelation} AS (
+      SELECT ${q("start")}, ${q("__start_key")},
+        CAST(row_number() OVER (
+          PARTITION BY ${q("__start_key")}
+          ORDER BY ${q("__edge_keys")}) - 1
+          AS BIGINT) AS ${q("pathId")}, ${q("steps")}
+      FROM ${completeRelation}
+    )
+    ${graphRouteResultSelect(rankedRelation, input, edgeIdColumn, true)}`;
+}
+function temporalFindCyclesSelect(prepared, direction, temporal, typedEdgeId, edgeKey, edgeWeight, distanceType, stepType, input, edgeIdColumn) {
+    const q = quoteIdentifier;
+    const relations = prepared.relationNames([
+        "graph_start_values",
+        "graph_starts",
+        "graph_temporal_settings",
+        "graph_event_rows",
+        "graph_edges",
+        "graph_cycle_walks",
+        "graph_complete_cycles",
+        "graph_ranked_cycles",
+    ]);
+    const startValuesRelation = relations.graph_start_values;
+    const startsRelation = relations.graph_starts;
+    const settingsRelation = relations.graph_temporal_settings;
+    const eventRowsRelation = relations.graph_event_rows;
+    const edgesRelation = relations.graph_edges;
+    const walksRelation = relations.graph_cycle_walks;
+    const completeRelation = relations.graph_complete_cycles;
+    const rankedRelation = relations.graph_ranked_cycles;
+    const edgeFrom = `${q("edges")}.${q("__from")}`;
+    const edgeTo = `${q("edges")}.${q("__to")}`;
+    const edgeFromKey = `${q("edges")}.${q("__from_key")}`;
+    const edgeToKey = `${q("edges")}.${q("__to_key")}`;
+    const edgeIdentity = `${q("edges")}.${q("__edge_id")}`;
+    const edgeIdentityKey = `${q("edges")}.${q("__edge_key")}`;
+    const edgeCost = `${q("edges")}.${q("__weight")}`;
+    const walkDistance = `${q("walks")}.${q("distance")}`;
+    const candidateDistance = `CAST(${walkDistance} + ${edgeCost} AS ${distanceType})`;
+    const gap = `${q("settings")}.${q("__gap")}`;
+    const step = (distance) => `struct_pack(
+          ${q("edgeId")} := ${edgeIdentity},
+          ${q("source")} := ${edgeFrom},
+          ${q("target")} := ${edgeTo},
+          ${q("weight")} := ${edgeCost},
+          ${q("distance")} := ${distance}
+        )`;
+    return `WITH RECURSIVE ${settingsRelation} AS MATERIALIZED (
+      SELECT CAST(? AS HUGEINT) AS ${q("__gap")}
+    ), ${startValuesRelation}(${q("start")}) AS (
+      VALUES ${prepared.startValues}
+    ), ${startsRelation} AS (
+      SELECT ${q("start")},
+        ${prepared.key(q("start"))} AS ${q("__start_key")}
+      FROM ${startValuesRelation}
+    ), ${eventRowsRelation} AS MATERIALIZED (
+      ${prepared.edges(direction, [
+        `${typedEdgeId} AS ${q("__edge_id")}`,
+        `${edgeKey} AS ${q("__edge_key")}`,
+        `${edgeWeight} AS ${q("__weight")}`,
+        ...temporal.eventSelections("edges"),
+    ])}
+    ), ${edgesRelation} AS MATERIALIZED (
+      SELECT *
+      FROM ${eventRowsRelation} AS ${q("events")}
+      WHERE ${temporal.eventValidity("events")}
+    ), ${walksRelation}(
+      ${q("start")}, ${q("__start_key")}, ${q("node")},
+      ${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")}
+    ) AS (
+      SELECT ${q("starts")}.${q("start")},
+        ${q("starts")}.${q("__start_key")}, ${edgeTo}, ${edgeToKey},
+        CASE WHEN ${edgeFromKey} = ${edgeToKey}
+          THEN [${edgeFromKey}]
+          ELSE [${edgeFromKey}, ${edgeToKey}]
+        END,
+        [${q("edges")}.${q("__event_id")}], [${edgeIdentityKey}],
+        [${step(edgeCost)}]::${stepType}[], ${edgeCost},
+        ${edgeFromKey} = ${edgeToKey},
+        ${q("edges")}.${q("__event_id")},
+        ${q("edges")}.${q("__event_start")},
+        ${q("edges")}.${q("__event_end")}
+      FROM ${edgesRelation} AS ${q("edges")}
+      INNER JOIN ${startsRelation} AS ${q("starts")}
+        ON ${q("starts")}.${q("__start_key")} = ${edgeFromKey}
+      UNION ALL
+      SELECT ${q("walks")}.${q("start")},
+        ${q("walks")}.${q("__start_key")}, ${edgeTo}, ${edgeToKey},
+        list_append(${q("walks")}.${q("__visited")}, ${edgeToKey}),
+        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)}),
+        ${candidateDistance},
+        ${edgeToKey} = ${q("walks")}.${q("__start_key")},
+        ${q("edges")}.${q("__event_id")},
+        ${q("edges")}.${q("__event_start")},
+        ${q("edges")}.${q("__event_end")}
+      FROM ${walksRelation} AS ${q("walks")}
+      INNER JOIN ${edgesRelation} AS ${q("edges")}
+        ON ${q("walks")}.${q("__node_key")} = ${edgeFromKey}
+      CROSS JOIN ${settingsRelation} AS ${q("settings")}
+      WHERE NOT ${q("walks")}.${q("closed")}
+        AND NOT list_contains(${q("walks")}.${q("__event_ids")},
+          ${q("edges")}.${q("__event_id")})
+        AND (
+          ${edgeToKey} = ${q("walks")}.${q("__start_key")}
+          OR NOT list_contains(${q("walks")}.${q("__visited")}, ${edgeToKey})
+        )
+        AND ${temporal.transition("walks", "edges", direction, gap)}
+    ), ${completeRelation} AS (
+      SELECT DISTINCT ${q("start")}, ${q("__start_key")},
+        ${q("__edge_keys")}, ${q("steps")}
+      FROM ${walksRelation}
+      WHERE ${q("closed")}
+    ), ${rankedRelation} AS (
+      SELECT ${q("start")}, ${q("__start_key")},
+        CAST(row_number() OVER (
+          PARTITION BY ${q("__start_key")}
+          ORDER BY ${q("__edge_keys")}) - 1
+          AS BIGINT) AS ${q("pathId")}, ${q("steps")}
+      FROM ${completeRelation}
+    )
+    ${graphRouteResultSelect(rankedRelation, input, edgeIdColumn, true)}`;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"fuzzyClean.d.ts","sourceRoot":"","sources":["../../src/methods/fuzzyClean.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,MAAM,CAAC,EACH,OAAO,GACP,eAAe,GACf,kBAAkB,GAClB,iBAAiB,CAAC;IACtB,QAAQ,CAAC,EACL,YAAY,GACZ,eAAe,GACf,gBAAgB,GAChB,aAAa,GACb,UAAU,CAAC;IACf,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAC3B,GACL,IAAI,CAYN"}
+{"version":3,"file":"fuzzyClean.d.ts","sourceRoot":"","sources":["../../src/methods/fuzzyClean.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AASvD,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,MAAM,CAAC,EACH,OAAO,GACP,eAAe,GACf,kBAAkB,GAClB,iBAAiB,CAAC;IACtB,QAAQ,CAAC,EACL,YAAY,GACZ,eAAe,GACf,gBAAgB,GAChB,aAAa,GACb,UAAU,CAAC;IACf,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAC3B,GACL,IAAI,CAWN"}