@nshiab/simple-data-analysis-core 2.1.12 → 2.1.13

package/esm/methods/outliersIQR.d.ts

@@ -1,5 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function outliersIQR(simpleTable: SimpleTable, column: string, newColumn: string, options?: {
-    by?: string | string[];
-}): void;
-//# sourceMappingURL=outliersIQR.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"outliersIQR.d.ts","sourceRoot":"","sources":["../../src/methods/outliersIQR.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACnB,QAWP"}

package/esm/methods/outliersIQR.js

@@ -1,37 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import queueOp from "../helpers/queueOp.js";
-import stringToArray from "../helpers/stringToArray.js";
-export default function outliersIQR(simpleTable, column, newColumn, options = {}) {
-    options = structuredClone(options);
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "outliersIQR()",
-        parameters: { column, newColumn, options },
-        needsSchema: false,
-        buildSelect: (input) => outliersIQRSelect(input, column, newColumn, options),
-    });
-}
-function outliersIQRSelect(input, column, newColumn, options = {}) {
-    const by = options.by
-        ? stringToArray(options.by).map((d) => `${quoteIdentifier(d)}`)
-        : [];
-    const partition = by.length > 0 ? `PARTITION BY ${by.join(", ")}` : "";
-    const quantile = (fraction) => `IF(COUNT(${quoteIdentifier(column)}) OVER (${partition}) % 2 = 0,
-      quantile_disc(${quoteIdentifier(column)}, ${fraction}) OVER (${partition}),
-      quantile_cont(${quoteIdentifier(column)}, ${fraction}) OVER (${partition})
-    )`;
-    // q1/q3 are computed as window values (one pass) instead of a per-category
-    // CTE joined back through a correlated subquery per row.
-    return `SELECT * EXCLUDE ("_sda_q1", "_sda_q3"), CASE
-        WHEN ${quoteIdentifier(column)} > "_sda_q3" + ("_sda_q3" - "_sda_q1") * 1.5
-          OR ${quoteIdentifier(column)} < "_sda_q1" - ("_sda_q3" - "_sda_q1") * 1.5
-        THEN TRUE
-        ELSE FALSE
-    END AS ${quoteIdentifier(newColumn)}
-    FROM (
-        SELECT *,
-            ${quantile(0.25)} AS "_sda_q1",
-            ${quantile(0.75)} AS "_sda_q3"
-        FROM ${input}
-    ) "_sda"`;
-}

package/esm/methods/pad.d.ts

@@ -1,6 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function pad(simpleTable: SimpleTable, columns: string | string[], length: number, options?: {
-    side?: "left" | "right";
-    character?: string;
-}): void;
-//# sourceMappingURL=pad.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"pad.d.ts","sourceRoot":"","sources":["../../src/methods/pad.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,GAAG,CACzB,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAC1B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,QAqB9D"}

package/esm/methods/pad.js

@@ -1,55 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import queueOp from "../helpers/queueOp.js";
-import stringToArray from "../helpers/stringToArray.js";
-export default function pad(simpleTable, columns, length, options = {}) {
-    if (!Number.isFinite(length) || !Number.isInteger(length) || length < 0) {
-        throw new Error("pad() length must be a finite integer greater than or equal to 0.");
-    }
-    columns = Array.isArray(columns) ? [...columns] : columns;
-    options = structuredClone(options);
-    const columnList = stringToArray(columns);
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "pad()",
-        parameters: { columns, length, options },
-        needsSchema: true,
-        preservesSchema: true,
-        values: padValues(columnList, length, options),
-        buildSelect: (input, schema) => padSelect(input, schema, columnList, length, options),
-    });
-}
-function padSelect(input, schema, columns, length, options) {
-    for (const column of columns) {
-        if (schema[column] !== "VARCHAR") {
-            throw new Error(`The column ${quoteIdentifier(column)} is of type ${schema[column]}. The pad() method only works with string (VARCHAR) columns. Please convert the column to string first with the .convert() method.`);
-        }
-    }
-    const usedNames = new Set(Object.keys(schema));
-    const overflowAliases = columns.map((_, index) => {
-        let alias = `__sda_pad_overflow_${index}`;
-        while (usedNames.has(alias)) {
-            alias += "_";
-        }
-        usedNames.add(alias);
-        return alias;
-    });
-    const func = options.side === "right" ? "RPAD" : "LPAD";
-    const counts = columns.map((column, index) => `COUNT(*) FILTER (WHERE LENGTH(${quoteIdentifier(column)}) > ${length}) OVER () AS ${quoteIdentifier(overflowAliases[index])}`).join(", ");
-    const replacements = columns.map((column, index) => {
-        const alias = quoteIdentifier(overflowAliases[index]);
-        return `CASE WHEN ${alias} > 0 THEN error(CONCAT(?, CAST(${alias} AS VARCHAR), ?)) ELSE ${func}(${quoteIdentifier(column)}, ${length}, ?) END AS ${quoteIdentifier(column)}`;
-    }).join(", ");
-    const excluded = overflowAliases.map(quoteIdentifier).join(", ");
-    return `SELECT * EXCLUDE (${excluded}) REPLACE (${replacements})
-FROM (
-  SELECT *, ${counts} FROM ${input}
-) AS ${quoteIdentifier("__sda_pad_source")}`;
-}
-function padValues(columns, length, options) {
-    const character = options.character ?? "0";
-    return columns.flatMap((column) => [
-        `The column ${quoteIdentifier(column)} has `,
-        ` string(s) exceeding the target length of ${length}. The pad() method does not truncate. Shorten the strings first or use a larger target length.`,
-        character,
-    ]);
-}

package/esm/methods/paths.d.ts

@@ -1,13 +0,0 @@
-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 & {
-    elapsedTime?: boolean;
-    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/esm/methods/paths.d.ts.map

@@ -1 +0,0 @@
-{"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,294 +0,0 @@
-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";
-import prepareGraphTemporalSql, { prepareGraphTemporalOptions, } from "../helpers/prepareGraphTemporalSql.js";
-import queueGraphResult from "../helpers/queueGraphResult.js";
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import validateGraphTemporalEvents from "../helpers/validateGraphTemporalEvents.js";
-export default 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 metric = prepareGraphMetricOptions(options, "paths()", false);
-    const endpoints = prepareGraphRouteEndpoints(start, end, "paths()");
-    const direction = options.direction ?? "outgoing";
-    const temporalOptions = prepareGraphTemporalOptions(options, direction, "paths()");
-    options = structuredClone(options);
-    const parameters = {
-        sourceColumn,
-        targetColumn,
-        edgeId,
-        start,
-        end,
-        options,
-    };
-    return queueGraphResult(simpleTable, {
-        method: "paths()",
-        parameters,
-        outputTable: options.outputTable,
-        preflight: temporalOptions === undefined
-            ? undefined
-            : (input) => validateGraphTemporalEvents(input, temporalOptions, "paths()", parameters),
-        values: (schema) => {
-            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()");
-            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, 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()", metric.elapsedTime);
-        },
-    });
-}
-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, elapsedTime);
-    }
-    const distanceType = route.distanceType;
-    const q = quoteIdentifier;
-    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}
-    )
-    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn)}`;
-}
-function temporalPathsSelect(route, direction, temporal, elapsedTime) {
-    const prepared = route.traversal;
-    const distanceType = route.distanceType;
-    const q = quoteIdentifier;
-    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 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}${elapsedTime
-        ? `, ${q("elapsedTimeMs")} := ${temporal.elapsedMilliseconds(temporal.journeyElapsed("edges", journeyAnchor, direction))}`
-        : ""}
-        )`;
-    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")}${elapsedTime ? `, ${q("__journey_anchor")}` : ""}
-    ) AS (
-      SELECT ${edgeTo}, ${edgeToKey},
-        [${q("__start_key")}, ${edgeToKey}], [${edgeKey}],
-        [${step(edgeCost, firstAnchor)}], ${edgeCost},
-        ${q("edges")}.${q("__event_id")},
-        ${q("edges")}.${q("__event_start")},
-        ${q("edges")}.${q("__event_end")}${elapsedTime ? `, ${firstAnchor}` : ""}
-      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, anchor)}),
-        ${candidateDistance}, ${q("edges")}.${q("__event_id")},
-        ${q("edges")}.${q("__event_start")},
-        ${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}
-      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}
-    )
-    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn, false, elapsedTime)}`;
-}

package/esm/methods/perimeter.d.ts

@@ -1,7 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function perimeter(simpleTable: SimpleTable, newColumn: string, options?: {
-    unit?: "m" | "km";
-    column?: string;
-    decimals?: number;
-}): void;
-//# sourceMappingURL=perimeter.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"perimeter.d.ts","sourceRoot":"","sources":["../../src/methods/perimeter.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,QAyBxE"}

package/esm/methods/perimeter.js

@@ -1,25 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import assertNewColumns from "../helpers/assertNewColumns.js";
-import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
-import queueOp from "../helpers/queueOp.js";
-export default function perimeter(simpleTable, newColumn, options = {}) {
-    options = structuredClone(options);
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "perimeter()",
-        parameters: { newColumn, options },
-        needsSchema: true,
-        needsSpatial: true,
-        buildSelect: (input, types) => {
-            assertNewColumns(types, [newColumn], "perimeter()");
-            const column = typeof options.column === "string"
-                ? options.column
-                : findGeoColumnFromSchema(types, "perimeter()", simpleTable.name);
-            let expression = `ST_Perimeter_Spheroid(${quoteIdentifier(column)}) ${options.unit === "km" ? "/ 1000" : ""}`;
-            if (typeof options.decimals === "number") {
-                expression = `ROUND(${expression}, ${options.decimals})`;
-            }
-            return `SELECT *, CAST(${expression} AS DOUBLE) AS ${quoteIdentifier(newColumn)} FROM ${input}`;
-        },
-    });
-}

package/esm/methods/quantiles.d.ts

@@ -1,5 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function quantiles(simpleTable: SimpleTable, column: string, count: number, newColumn: string, options?: {
-    by?: string | string[];
-}): void;
-//# sourceMappingURL=quantiles.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"quantiles.d.ts","sourceRoot":"","sources":["../../src/methods/quantiles.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACnB,QAuBP"}

package/esm/methods/quantiles.js

@@ -1,22 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import assertNewColumns from "../helpers/assertNewColumns.js";
-import queueOp from "../helpers/queueOp.js";
-import stringToArray from "../helpers/stringToArray.js";
-export default function quantiles(simpleTable, column, count, newColumn, options = {}) {
-    options = structuredClone(options);
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "quantiles()",
-        parameters: { column, count, newColumn, options },
-        needsSchema: true,
-        buildSelect: (input, schema) => {
-            assertNewColumns(schema, [newColumn], "quantiles()");
-            const by = options.by ? stringToArray(options.by) : [];
-            const partition = by.length === 0
-                ? ""
-                : `PARTITION BY ${by.map((d) => `${quoteIdentifier(d)}`).join(",")} `;
-            return `SELECT *, ntile(${count}) OVER (${partition}ORDER BY ${quoteIdentifier(column)}) AS ${quoteIdentifier(newColumn)}
-    FROM ${input}`;
-        },
-    });
-}

package/esm/methods/randomPoint.d.ts

@@ -1,6 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function randomPoint(simpleTable: SimpleTable, newColumn: string, tries: number, options?: {
-    column?: string;
-    strict?: boolean;
-}): void;
-//# sourceMappingURL=randomPoint.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"randomPoint.d.ts","sourceRoot":"","sources":["../../src/methods/randomPoint.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,QAmBpD"}

package/esm/methods/randomPoint.js

@@ -1,105 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import findGeoColumn from "../helpers/findGeoColumn.js";
-import mergeOptions from "../helpers/mergeOptions.js";
-import queryDB from "../helpers/queryDB.js";
-import queueOp from "../helpers/queueOp.js";
-import ensureSpatial from "../helpers/ensureSpatial.js";
-export default function randomPoint(simpleTable, newColumn, tries, options = {}) {
-    options = structuredClone(options);
-    // This validation doesn't need the database, so it stays at call time.
-    if (!Number.isFinite(tries) || !Number.isInteger(tries) || tries < 0) {
-        throw new Error("randomPoint() tries must be a finite integer greater than or equal to 0.");
-    }
-    // The generated points are checked against the data afterwards, so
-    // randomPoint can't be expressed as a single SELECT over its input: it
-    // executes as a barrier.
-    queueOp(simpleTable, {
-        kind: "barrier",
-        method: "randomPoint()",
-        parameters: { newColumn, tries, options },
-        execute: () => executeRandomPoint(simpleTable, newColumn, tries, options),
-    });
-}
-async function executeRandomPoint(simpleTable, newColumn, tries, options) {
-    await ensureSpatial(simpleTable);
-    const column = typeof options.column === "string"
-        ? options.column
-        : await findGeoColumn(simpleTable, "randomPoint()");
-    const geoType = await simpleTable.getProjection(column);
-    await queryDB(simpleTable, randomPointQuery(simpleTable.name, column, newColumn, tries, geoType, options.strict !== false), mergeOptions(simpleTable, {
-        table: simpleTable.name,
-        method: "randomPoint()",
-        parameters: { column, newColumn, tries, options, geoType },
-    }));
-}
-function randomPointQuery(table, column, newColumn, tries, geoType, strict) {
-    // Recursive CTE approach: each iteration only carries forward the rows that
-    // have NOT yet found a valid interior point, so DuckDB stops per-row as soon
-    // as ST_Within is satisfied — giving O(1) behaviour for easy polygons instead
-    // of the O(N) materialisation that occurs with LATERAL + range() + WHERE.
-    //
-    // Zero-tries contract: `WHERE 1 <= ${tries}` in the base case
-    // produces no rows when tries is 0, so the LEFT JOIN returns NULL for
-    // every row and the UPDATE sets the column to NULL — no special-case branch
-    // needed and the normal UPDATE code path is always exercised.
-    //
-    // Volatility guard: `CASE WHEN (rid + n) IS NOT NULL THEN random() END`
-    // prevents the planner from constant-folding random() across iterations while
-    // still evaluating to random() for every non-null row.
-    const failedExpression = strict
-        ? `CASE WHEN v.failed_count > 0 THEN error(CONCAT(CAST(v.failed_count AS VARCHAR), ' points could not be generated. Consider increasing tries or set options.strict to false.')) ELSE v.pt::${geoType} END`
-        : `v.pt::${geoType}`;
-    const select = newColumn === column
-        ? `t.* REPLACE (${failedExpression} AS ${quoteIdentifier(newColumn)})`
-        : `t.*, ${failedExpression} AS ${quoteIdentifier(newColumn)}`;
-    return `CREATE OR REPLACE TABLE ${quoteIdentifier(table)} AS
-WITH RECURSIVE
-base AS (
-    SELECT
-        rowid AS rid,
-        ${quoteIdentifier(column)} AS geom,
-        ST_XMin(${quoteIdentifier(column)}) AS xmin,
-        ST_XMax(${quoteIdentifier(column)}) - ST_XMin(${quoteIdentifier(column)}) AS xdiff,
-        ST_YMin(${quoteIdentifier(column)}) AS ymin,
-        ST_YMax(${quoteIdentifier(column)}) - ST_YMin(${quoteIdentifier(column)}) AS ydiff
-    FROM ${quoteIdentifier(table)}
-),
-attempts(rid, geom, xmin, xdiff, ymin, ydiff, pt, n) AS (
-    SELECT
-        rid, geom, xmin, xdiff, ymin, ydiff,
-        ST_Point(
-            xmin + CASE WHEN rid IS NOT NULL THEN random() END * xdiff,
-            ymin + CASE WHEN rid IS NOT NULL THEN random() END * ydiff
-        ),
-        1
-    FROM base
-    WHERE 1 <= ${tries}
-    UNION ALL
-    SELECT
-        rid, geom, xmin, xdiff, ymin, ydiff,
-        ST_Point(
-            xmin + CASE WHEN (rid + n) IS NOT NULL THEN random() END * xdiff,
-            ymin + CASE WHEN (rid + n) IS NOT NULL THEN random() END * ydiff
-        ),
-        n + 1
-    FROM attempts
-    WHERE NOT ST_Within(pt, geom) AND n < ${tries}
-),
-valid_points AS (
-    SELECT rid, pt
-    FROM attempts
-    WHERE ST_Within(pt, geom)
-    QUALIFY ROW_NUMBER() OVER (PARTITION BY rid ORDER BY n) = 1
-),
-generated AS (
-    SELECT
-        b.rid,
-        vp.pt,
-        COUNT(*) FILTER (WHERE vp.pt IS NULL) OVER () AS failed_count
-    FROM (SELECT rowid AS rid FROM ${quoteIdentifier(table)}) b
-    LEFT JOIN valid_points vp ON b.rid = vp.rid
-)
-SELECT ${select}
-FROM ${quoteIdentifier(table)} t
-JOIN generated v ON t.rowid = v.rid;`;
-}

package/esm/methods/ranks.d.ts

@@ -1,7 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function ranks(simpleTable: SimpleTable, column: string, newColumn: string, options?: {
-    order?: "asc" | "desc";
-    by?: string | string[];
-    dense?: boolean;
-}): void;
-//# sourceMappingURL=ranks.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ranks.d.ts","sourceRoot":"","sources":["../../src/methods/ranks.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,KAAK,CAC3B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IACvB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;CACZ,QAyBP"}