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

package/script/methods/neighbors.js

@@ -0,0 +1,120 @@
+"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 = neighbors;
+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"));
+function neighbors(simpleTable, sourceColumn, targetColumn, startNodes, options = {}) {
+    if (typeof sourceColumn !== "string") {
+        throw new TypeError("neighbors() sourceColumn must be a string.");
+    }
+    if (typeof targetColumn !== "string") {
+        throw new TypeError("neighbors() targetColumn must be a string.");
+    }
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+        throw new TypeError("neighbors() options must be an object.");
+    }
+    if (options.direction !== undefined &&
+        !["outgoing", "incoming", "both"].includes(options.direction)) {
+        throw new TypeError('neighbors() options.direction must be "outgoing", "incoming", or "both".');
+    }
+    if (options.outputTable !== undefined &&
+        typeof options.outputTable !== "string" &&
+        typeof options.outputTable !== "boolean") {
+        throw new TypeError("neighbors() options.outputTable must be a string or boolean.");
+    }
+    const preparedStarts = (0, prepareGraphStarts_js_1.default)(startNodes, "neighbors()", "startNodes");
+    options = structuredClone(options);
+    const direction = options.direction ?? "outgoing";
+    const parameters = {
+        sourceColumn,
+        targetColumn,
+        startNodes: structuredClone(startNodes),
+        options,
+    };
+    return (0, queueGraphResult_js_1.default)(simpleTable, {
+        method: "neighbors()",
+        parameters,
+        outputTable: options.outputTable,
+        values: (schema) => {
+            validateStarts(schema, sourceColumn, targetColumn, preparedStarts);
+            return preparedStarts.values;
+        },
+        buildSelect: (input, schema) => neighborsSelect(input, schema, sourceColumn, targetColumn, preparedStarts, direction),
+        outputSchema: (schema) => {
+            const endpoints = validateStarts(schema, sourceColumn, targetColumn, preparedStarts);
+            return { start: endpoints.idType, node: endpoints.idType };
+        },
+    });
+}
+function validateStarts(schema, source, target, starts) {
+    return (0, prepareGraphTraversal_js_1.validateGraphStarts)(schema, source, target, starts, "neighbors()", "startNodes");
+}
+function neighborsSelect(input, schema, source, target, starts, direction) {
+    const prepared = (0, prepareGraphTraversal_js_1.default)(input, schema, source, target, starts, "neighbors()", "startNodes");
+    const relations = prepared.relationNames([
+        "graph_starts",
+        "graph_edges",
+        "neighbor_matches",
+    ]);
+    const startsRelation = relations.graph_starts;
+    const edgesRelation = relations.graph_edges;
+    const matchesRelation = relations.neighbor_matches;
+    return `WITH ${startsRelation}(${(0, quoteIdentifier_js_1.default)("start")}) AS (
+      VALUES ${prepared.startValues}
+    ), ${edgesRelation} AS (
+      ${prepared.edges(direction)}
+    ), ${matchesRelation} AS (
+      SELECT ${(0, quoteIdentifier_js_1.default)("starts")}.${(0, quoteIdentifier_js_1.default)("start")},
+        ${(0, quoteIdentifier_js_1.default)("edges")}.${(0, quoteIdentifier_js_1.default)("__to")} AS ${(0, quoteIdentifier_js_1.default)("node")},
+        ${(0, quoteIdentifier_js_1.default)("edges")}.${(0, quoteIdentifier_js_1.default)("__from_key")} AS ${(0, quoteIdentifier_js_1.default)("__start_key")},
+        ${(0, quoteIdentifier_js_1.default)("edges")}.${(0, quoteIdentifier_js_1.default)("__to_key")} AS ${(0, quoteIdentifier_js_1.default)("__node_key")}
+      FROM ${edgesRelation} AS ${(0, quoteIdentifier_js_1.default)("edges")}
+      INNER JOIN ${startsRelation} AS ${(0, quoteIdentifier_js_1.default)("starts")}
+        ON ${(0, quoteIdentifier_js_1.default)("edges")}.${(0, quoteIdentifier_js_1.default)("__from_key")} =
+          ${prepared.key(`${(0, quoteIdentifier_js_1.default)("starts")}.${(0, quoteIdentifier_js_1.default)("start")}`)}
+    )
+    SELECT ${(0, quoteIdentifier_js_1.default)("start")}, ${(0, quoteIdentifier_js_1.default)("node")}
+    FROM (
+      SELECT DISTINCT ${(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")}
+      FROM ${matchesRelation}
+    ) AS ${(0, quoteIdentifier_js_1.default)("distinct_neighbors")}
+    ORDER BY ${(0, quoteIdentifier_js_1.default)("__start_key")}, ${(0, quoteIdentifier_js_1.default)("__node_key")}`;
+}

package/script/methods/normalizeVector.d.ts

@@ -0,0 +1,5 @@
+import type SimpleTable from "../class/SimpleTable.js";
+type Options = NonNullable<Parameters<SimpleTable["normalizeVector"]>[2]>;
+export default function normalizeVector(table: SimpleTable, column: string, newColumn: string, options?: Options): void;
+export {};
+//# sourceMappingURL=normalizeVector.d.ts.map

package/script/methods/normalizeVector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeVector.d.ts","sourceRoot":"","sources":["../../src/methods/normalizeVector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAOvD,KAAK,OAAO,GAAG,WAAW,CAAC,UAAU,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAE1E,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,OAAY,GACpB,IAAI,CAiBN"}

package/script/methods/normalizeVector.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = normalizeVector;
+const foldIdentifier_js_1 = __importDefault(require("../helpers/foldIdentifier.js"));
+const prepareNumericFeatures_js_1 = __importDefault(require("../helpers/prepareNumericFeatures.js"));
+const publishPreparedColumns_js_1 = __importDefault(require("../helpers/publishPreparedColumns.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+function normalizeVector(table, column, newColumn, options = {}) {
+    if (options.normalization !== undefined &&
+        options.normalization !== "dimensionMinMax" &&
+        options.normalization !== "rowL2") {
+        throw new Error('normalizeVector() options.normalization must be "dimensionMinMax" or "rowL2".');
+    }
+    const settings = structuredClone(options);
+    (0, queueOp_js_1.default)(table, {
+        kind: "barrier",
+        method: "normalizeVector()",
+        parameters: { column, newColumn, options: settings },
+        execute: () => execute(table, column, newColumn, settings),
+    });
+}
+async function execute(table, column, newColumn, options) {
+    const normalization = options.normalization ?? "dimensionMinMax";
+    const overwrite = (0, foldIdentifier_js_1.default)(column) === (0, foldIdentifier_js_1.default)(newColumn);
+    if (!overwrite) {
+        const sourceColumns = Object.keys(await table.getTypes());
+        if (sourceColumns.some((name) => (0, foldIdentifier_js_1.default)(name) === (0, foldIdentifier_js_1.default)(newColumn))) {
+            throw new Error(`normalizeVector() cannot create ${(0, quoteIdentifier_js_1.default)(newColumn)} because that column already exists. Remove it first or choose a different name.`);
+        }
+    }
+    const prepared = await (0, prepareNumericFeatures_js_1.default)(table, { kind: "vector", column }, { method: "normalizeVector()" });
+    const connection = table.connection;
+    const q = quoteIdentifier_js_1.default;
+    const suffix = crypto.randomUUID().replaceAll("-", "");
+    const statsName = `__sda_normalize_vector_${suffix}_stats`;
+    const resultName = `__sda_normalize_vector_${suffix}_result`;
+    const dimension = q(`__sda_dimension_${suffix}`);
+    const minimum = q(`__sda_min_${suffix}`);
+    const maximum = q(`__sda_max_${suffix}`);
+    const normalized = `__sda_normalized_${suffix}`;
+    try {
+        if (prepared.rowCount === 0) {
+            throw new Error("normalizeVector() requires at least one row; the dataset is empty.");
+        }
+        const sourceColumn = prepared.sourceColumns.find((name) => (0, foldIdentifier_js_1.default)(name) === (0, foldIdentifier_js_1.default)(column));
+        if (normalization === "rowL2") {
+            // Scale before squaring so extreme finite magnitudes do not overflow
+            // or underflow the norm. A zero vector stays zero.
+            await connection.run(`CREATE TEMP TABLE ${q(resultName)} AS
+         WITH magnitudes AS (
+           SELECT ${q(prepared.rowIdColumn)}, ${q(prepared.vectorColumn)} AS vec,
+             list_max(list_transform(${q(prepared.vectorColumn)}, value -> abs(value))) AS magnitude
+           FROM ${q(prepared.relation)}
+         ), scaled AS (
+           SELECT *, list_transform(vec, value -> value / nullif(magnitude, 0)) AS unit_scale
+           FROM magnitudes
+         ), norms AS (
+           SELECT *, sqrt(list_sum(list_transform(unit_scale, value -> value * value))) AS norm
+           FROM scaled
+         )
+         SELECT ${q(prepared.rowIdColumn)},
+           (CASE WHEN magnitude = 0 THEN vec::DOUBLE[]
+             ELSE list_transform(unit_scale, value -> value / norm)
+           END)::DOUBLE[${prepared.dimensions}] AS ${q(normalized)}
+         FROM norms`);
+        }
+        else {
+            await connection.run(`CREATE TEMP TABLE ${q(statsName)} AS
+         SELECT ordinal::BIGINT AS ${dimension}, min(value)::DOUBLE AS ${minimum},
+           max(value)::DOUBLE AS ${maximum}
+         FROM ${q(prepared.relation)} p,
+           UNNEST(p.${q(prepared.vectorColumn)}::DOUBLE[]) WITH ORDINALITY AS values(value, ordinal)
+         GROUP BY ordinal`);
+            const invalidStats = Number((await connection.runAndReadAll(`SELECT count(*) FROM ${q(statsName)}
+           WHERE NOT isfinite(${minimum}) OR NOT isfinite(${maximum})`)).getRowsJS()[0][0]);
+            if (invalidStats > 0) {
+                throw new Error(`normalizeVector() found ${invalidStats} dimension${invalidStats === 1 ? "" : "s"} with non-finite aggregate values after conversion to DOUBLE.`);
+            }
+            const constantDimensions = (await connection.runAndReadAll(`SELECT ${dimension} FROM ${q(statsName)}
+         WHERE ${minimum} = ${maximum} ORDER BY ${dimension}`)).getRowsJS().map((row) => Number(row[0]));
+            if (constantDimensions.length > 0) {
+                throw new Error(`normalizeVector() cannot scale constant dimension${constantDimensions.length === 1 ? "" : "s"} ${constantDimensions.join(", ")} in column ${q(sourceColumn)} because the range is zero. Remove ${constantDimensions.length === 1
+                    ? "that dimension"
+                    : "those dimensions"} before normalizing. Conversion to DOUBLE can also collapse distinct large integers or decimals at its precision limit.`);
+            }
+            const value = `p.${q(prepared.vectorColumn)}[s.${dimension}]`;
+            const min = `s.${minimum}`;
+            const max = `s.${maximum}`;
+            // Dividing both sides by the larger magnitude when a range crosses zero
+            // avoids overflowing max - min for extreme finite DOUBLE values.
+            const scaled = `CASE
+        WHEN ${min} < 0 AND ${max} > 0 AND -${min} >= ${max}
+          THEN ((${value} / -${min}) + 1.0) / ((${max} / -${min}) + 1.0)
+        WHEN ${min} < 0 AND ${max} > 0
+          THEN ((${value} / ${max}) + (-${min} / ${max})) /
+            (1.0 + (-${min} / ${max}))
+        ELSE (${value} - ${min}) / (${max} - ${min})
+      END`;
+            await connection.run(`CREATE TEMP TABLE ${q(resultName)} AS
+         SELECT p.${q(prepared.rowIdColumn)},
+           list(${scaled} ORDER BY s.${dimension})::DOUBLE[${prepared.dimensions}]
+             AS ${q(normalized)}
+         FROM ${q(prepared.relation)} p CROSS JOIN ${q(statsName)} s
+         GROUP BY p.${q(prepared.rowIdColumn)}`);
+        }
+        const invalidResults = Number((await connection.runAndReadAll(`SELECT count(*) FROM ${q(resultName)}
+         WHERE ${q(normalized)} IS NULL
+           OR list_count(${q(normalized)}) != ${prepared.dimensions}
+           OR NOT list_bool_and(list_transform(${q(normalized)}, value -> isfinite(value)))
+           OR list_min(${q(normalized)}) < ${normalization === "rowL2" ? -1 : 0}
+           OR list_max(${q(normalized)}) > 1`)).getRowsJS()[0][0]);
+        if (invalidResults > 0) {
+            throw new Error(`normalizeVector() produced non-finite or out-of-range values for ${invalidResults} row${invalidResults === 1 ? "" : "s"}. Rescale the source values before normalizing.`);
+        }
+        await (0, publishPreparedColumns_js_1.default)(table, prepared, {
+            method: "normalizeVector()",
+            parameters: { column, newColumn, options },
+            result: {
+                relation: resultName,
+                rowIdColumn: prepared.rowIdColumn,
+            },
+            outputs: [{
+                    name: overwrite ? sourceColumn : newColumn,
+                    expression: `r.${q(normalized)}`,
+                    replace: overwrite ? sourceColumn : undefined,
+                }],
+        });
+    }
+    finally {
+        await connection.run(`DROP TABLE IF EXISTS ${q(resultName)}`);
+        await connection.run(`DROP TABLE IF EXISTS ${q(statsName)}`);
+        await prepared.cleanup();
+    }
+}

package/script/methods/paths.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 PathsOptions = GraphTemporalOptions & {
+    direction?: GraphDirection;
+    outputTable?: string | boolean;
+    weight?: string;
+};
+export default function paths(simpleTable: SimpleTable, sourceColumn: string, targetColumn: string, edgeId: string, start: GraphId, end: GraphId, options?: PathsOptions): SimpleTable;
+export {};
+//# sourceMappingURL=paths.d.ts.map

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

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

package/script/methods/paths.js

@@ -0,0 +1,326 @@
+"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 = paths;
+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 paths(simpleTable, sourceColumn, targetColumn, edgeId, start, end, options = {}) {
+    if (typeof sourceColumn !== "string") {
+        throw new TypeError("paths() sourceColumn must be a string.");
+    }
+    if (typeof targetColumn !== "string") {
+        throw new TypeError("paths() targetColumn must be a string.");
+    }
+    if (typeof edgeId !== "string") {
+        throw new TypeError("paths() edgeId must be a string.");
+    }
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+        throw new TypeError("paths() options must be an object.");
+    }
+    if (options.direction !== undefined &&
+        !["outgoing", "incoming", "both"].includes(options.direction)) {
+        throw new TypeError('paths() options.direction must be "outgoing", "incoming", or "both".');
+    }
+    if (options.weight !== undefined && typeof options.weight !== "string") {
+        throw new TypeError("paths() options.weight must be a string.");
+    }
+    if (options.outputTable !== undefined &&
+        typeof options.outputTable !== "string" &&
+        typeof options.outputTable !== "boolean") {
+        throw new TypeError("paths() options.outputTable must be a string or boolean.");
+    }
+    const endpoints = (0, prepareGraphRouteSql_js_1.prepareGraphRouteEndpoints)(start, end, "paths()");
+    const direction = options.direction ?? "outgoing";
+    const temporalOptions = (0, prepareGraphTemporalSql_js_1.prepareGraphTemporalOptions)(options, direction, "paths()");
+    options = structuredClone(options);
+    const parameters = {
+        sourceColumn,
+        targetColumn,
+        edgeId,
+        start,
+        end,
+        options,
+    };
+    return (0, queueGraphResult_js_1.default)(simpleTable, {
+        method: "paths()",
+        parameters,
+        outputTable: options.outputTable,
+        preflight: temporalOptions === undefined
+            ? undefined
+            : (input) => (0, validateGraphTemporalEvents_js_1.default)(input, temporalOptions, "paths()", parameters),
+        values: (schema) => {
+            (0, prepareGraphRouteSql_js_1.validateGraphRouteInputs)(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "paths()");
+            const temporal = temporalOptions === undefined
+                ? undefined
+                : (0, prepareGraphTemporalSql_js_1.default)(schema, temporalOptions, "paths()");
+            return temporal === undefined
+                ? endpoints.values.values
+                : [temporal.gapParameter, ...endpoints.values.values];
+        },
+        buildSelect: (input, schema) => pathsSelect(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, "paths()");
+            if (temporalOptions !== undefined) {
+                (0, prepareGraphTemporalSql_js_1.default)(schema, temporalOptions, "paths()");
+            }
+            return (0, graphRouteResultSchema_js_1.default)(schema, validated.distanceType, "paths()");
+        },
+    });
+}
+function pathsSelect(input, schema, source, target, edgeId, routeEndpoints, direction, weight, temporalOptions) {
+    const route = (0, prepareGraphRouteSql_js_1.prepareGraphRouteSql)(input, schema, source, target, edgeId, routeEndpoints, weight, "paths()");
+    const prepared = route.traversal;
+    if (temporalOptions !== undefined) {
+        const temporal = (0, prepareGraphTemporalSql_js_1.default)(schema, temporalOptions, "paths()");
+        return temporalPathsSelect(route, direction, temporal);
+    }
+    const distanceType = route.distanceType;
+    const q = quoteIdentifier_js_1.default;
+    const relations = prepared.relationNames([
+        "graph_route_endpoints",
+        "graph_edges",
+        "graph_nodes",
+        "graph_to_end",
+        "graph_routes",
+        "graph_complete_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 routesRelation = relations.graph_routes;
+    const completeRelation = relations.graph_complete_routes;
+    const rankedRelation = relations.graph_ranked_routes;
+    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 candidateDistance = `CAST(${q("routes")}.${q("distance")} + ${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}
+    ), ${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 ${toEndRelation}
+        ON ${q("__start_key")} = ${q("__key")}
+      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")}
+      CROSS JOIN ${endpointRelation}
+      WHERE ${q("routes")}.${q("__node_key")} <> ${q("__end_key")}
+        AND NOT list_contains(${q("routes")}.${q("__visited")}, ${edgeToKey})
+    ), ${completeRelation} AS (
+      SELECT ${q("__edge_keys")}, ${q("steps")}
+      FROM ${routesRelation}
+      CROSS JOIN ${endpointRelation}
+      WHERE ${q("__node_key")} = ${q("__end_key")}
+    ), ${rankedRelation} AS (
+      SELECT CAST(row_number() OVER (ORDER BY ${q("__edge_keys")}) - 1 AS BIGINT) AS ${q("pathId")},
+        ${q("steps")}
+      FROM ${completeRelation}
+    )
+    ${(0, graphRouteResultSelect_js_1.default)(rankedRelation, route.input, route.edgeIdColumn)}`;
+}
+function temporalPathsSelect(route, direction, temporal) {
+    const prepared = route.traversal;
+    const distanceType = route.distanceType;
+    const q = quoteIdentifier_js_1.default;
+    const relations = prepared.relationNames([
+        "graph_route_endpoints",
+        "graph_temporal_settings",
+        "graph_event_rows",
+        "graph_edges",
+        "graph_nodes",
+        "graph_to_end",
+        "graph_routes",
+        "graph_complete_routes",
+        "graph_ranked_routes",
+    ]);
+    const endpointRelation = relations.graph_route_endpoints;
+    const settingsRelation = relations.graph_temporal_settings;
+    const eventRowsRelation = relations.graph_event_rows;
+    const edgesRelation = relations.graph_edges;
+    const nodesRelation = relations.graph_nodes;
+    const toEndRelation = relations.graph_to_end;
+    const routesRelation = relations.graph_routes;
+    const completeRelation = relations.graph_complete_routes;
+    const rankedRelation = relations.graph_ranked_routes;
+    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 candidateDistance = `CAST(${q("routes")}.${q("distance")} + ${edgeCost} AS ${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 `WITH RECURSIVE ${settingsRelation} AS MATERIALIZED (
+      SELECT CAST(? AS HUGEINT) AS ${q("__gap")}
+    ), ${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")}
+    ), ${eventRowsRelation} AS MATERIALIZED (
+      ${prepared.edges(direction, [
+        `${route.typedEdgeId} AS ${q("__edge_id")}`,
+        `${route.edgeKey} AS ${q("__edge_key")}`,
+        `${route.edgeWeight} AS ${q("__weight")}`,
+        ...temporal.eventSelections("edges"),
+    ])}
+    ), ${edgesRelation} AS MATERIALIZED (
+      SELECT *
+      FROM ${eventRowsRelation} AS ${q("events")}
+      WHERE ${temporal.eventValidity("events")}
+    ), ${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}
+    ), ${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")}
+      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")}
+      CROSS JOIN ${endpointRelation}
+      CROSS JOIN ${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)}
+    ), ${completeRelation} AS (
+      SELECT ${q("__edge_keys")}, ${q("steps")}
+      FROM ${routesRelation}
+      CROSS JOIN ${endpointRelation}
+      WHERE ${q("__node_key")} = ${q("__end_key")}
+    ), ${rankedRelation} AS (
+      SELECT CAST(row_number() OVER (ORDER BY ${q("__edge_keys")}) - 1 AS BIGINT)
+          AS ${q("pathId")}, ${q("steps")}
+      FROM ${completeRelation}
+    )
+    ${(0, graphRouteResultSelect_js_1.default)(rankedRelation, route.input, route.edgeIdColumn)}`;
+}

package/script/methods/reachable.d.ts

@@ -0,0 +1,11 @@
+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 ReachableOptions = GraphTemporalOptions & {
+    direction?: GraphDirection;
+    outputTable?: string | boolean;
+};
+export default function reachable(simpleTable: SimpleTable, sourceColumn: string, targetColumn: string, startNodes: GraphId | GraphId[], options?: ReachableOptions): SimpleTable;
+export {};
+//# sourceMappingURL=reachable.d.ts.map

package/script/methods/reachable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reachable.d.ts","sourceRoot":"","sources":["../../src/methods/reachable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,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;AAK7C,KAAK,gBAAgB,GAAG,oBAAoB,GAAG;IAC7C,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,OAAO,GAAG,OAAO,EAAE,EAC/B,OAAO,GAAE,gBAAqB,GAC7B,WAAW,CAkGb"}