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

package/esm/methods/findCycles.js

@@ -1,337 +0,0 @@
-import prepareGraphMetricOptions from "../helpers/prepareGraphMetricOptions.js";
-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 metric = prepareGraphMetricOptions(options, "findCycles()", false);
-    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) => {
-            const validated = validateFindCyclesInputs(schema, sourceColumn, targetColumn, edgeId, preparedStarts, options.weight);
-            graphRouteResultSchema(schema, validated.distanceType, "findCycles()", metric.elapsedTime);
-            const temporal = temporalOptions === undefined
-                ? undefined
-                : prepareGraphTemporalSql(schema, temporalOptions, "findCycles()");
-            return temporal === undefined
-                ? preparedStarts.values
-                : [temporal.gapParameter, ...preparedStarts.values];
-        },
-        buildSelect: (input, schema) => findCyclesSelect(input, schema, sourceColumn, targetColumn, edgeId, preparedStarts, direction, options.weight, temporalOptions, metric.elapsedTime),
-        outputSchema: (schema) => {
-            const validated = validateFindCyclesInputs(schema, sourceColumn, targetColumn, edgeId, preparedStarts, options.weight);
-            if (temporalOptions !== undefined) {
-                prepareGraphTemporalSql(schema, temporalOptions, "findCycles()");
-            }
-            return {
-                start: validated.nodeIdType,
-                ...graphRouteResultSchema(schema, validated.distanceType, "findCycles()", metric.elapsedTime),
-            };
-        },
-    });
-}
-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, elapsedTime) {
-    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}${elapsedTime ? `, ${q("elapsedTimeMs")} DOUBLE` : ""})`;
-    if (temporalOptions !== undefined) {
-        const temporal = prepareGraphTemporalSql(schema, temporalOptions, "findCycles()");
-        return temporalFindCyclesSelect(prepared, direction, temporal, typedEdgeId, edgeKey, edgeWeight, distanceType, stepType, input, edgeIdColumn, elapsedTime);
-    }
-    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, elapsedTime) {
-    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 firstAnchor = temporal.journeyAnchor("edges", direction);
-    const anchor = `${q("walks")}.${q("__journey_anchor")}`;
-    const step = (distance, journeyAnchor) => `struct_pack(
-          ${q("edgeId")} := ${edgeIdentity},
-          ${q("source")} := ${edgeFrom},
-          ${q("target")} := ${edgeTo},
-          ${q("weight")} := ${edgeCost},
-          ${q("distance")} := ${distance}${elapsedTime
-        ? `, ${q("elapsedTimeMs")} := ${temporal.elapsedMilliseconds(temporal.journeyElapsed("edges", journeyAnchor, direction))}`
-        : ""}
-        )`;
-    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")}${elapsedTime ? `, ${q("__journey_anchor")}` : ""}
-    ) 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, firstAnchor)}]::${stepType}[], ${edgeCost},
-        ${edgeFromKey} = ${edgeToKey},
-        ${q("edges")}.${q("__event_id")},
-        ${q("edges")}.${q("__event_start")},
-        ${q("edges")}.${q("__event_end")}${elapsedTime ? `, ${firstAnchor}` : ""}
-      FROM ${edgesRelation} AS ${q("edges")}
-      INNER JOIN ${startsRelation} AS ${q("starts")}
-        ON ${q("starts")}.${q("__start_key")} = ${edgeFromKey}
-      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, anchor)}),
-        ${candidateDistance},
-        ${edgeToKey} = ${q("walks")}.${q("__start_key")},
-        ${q("edges")}.${q("__event_id")},
-        ${q("edges")}.${q("__event_start")},
-        ${q("edges")}.${q("__event_end")}${elapsedTime ? `, ${anchor}` : ""}
-      FROM ${walksRelation} AS ${q("walks")}
-      INNER JOIN ${edgesRelation} AS ${q("edges")}
-        ON ${q("walks")}.${q("__node_key")} = ${edgeFromKey}
-      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, elapsedTime)}`;
-}

package/esm/methods/firstChars.d.ts

@@ -1,3 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function firstChars(simpleTable: SimpleTable, column: string, count: number): void;
-//# sourceMappingURL=firstChars.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"firstChars.d.ts","sourceRoot":"","sources":["../../src/methods/firstChars.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,QAYd"}

package/esm/methods/firstChars.js

@@ -1,11 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import queueOp from "../helpers/queueOp.js";
-export default function firstChars(simpleTable, column, count) {
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "firstChars()",
-        parameters: { column, count },
-        needsSchema: false,
-        buildSelect: (input) => `SELECT * REPLACE (LEFT(${quoteIdentifier(column)}, ${count}) AS ${quoteIdentifier(column)}) FROM ${input}`,
-    });
-}

package/esm/methods/fixGeo.d.ts

@@ -1,3 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function fixGeo(simpleTable: SimpleTable, column?: string): void;
-//# sourceMappingURL=fixGeo.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"fixGeo.d.ts","sourceRoot":"","sources":["../../src/methods/fixGeo.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,MAAM,CAC5B,WAAW,EAAE,WAAW,EACxB,MAAM,CAAC,EAAE,MAAM,QAqBhB"}

package/esm/methods/fixGeo.js

@@ -1,22 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
-import queueOp from "../helpers/queueOp.js";
-export default function fixGeo(simpleTable, column) {
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "fixGeo()",
-        parameters: { column },
-        needsSchema: true,
-        needsSpatial: true,
-        // The cast pins the geometry column back to its existing type, so the
-        // schema is unchanged.
-        preservesSchema: true,
-        buildSelect: (input, types) => {
-            const col = column ??
-                findGeoColumnFromSchema(types, "fixGeo()", simpleTable.name);
-            // The schema type carries the projection (e.g. GEOMETRY('EPSG:4326')),
-            // so the cast keeps it on the new geometries.
-            return `SELECT * REPLACE (ST_MakeValid(${quoteIdentifier(col)})::${types[col]} AS ${quoteIdentifier(col)}) FROM ${input}`;
-        },
-    });
-}

package/esm/methods/flipCoordinates.d.ts

@@ -1,3 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function flipCoordinates(simpleTable: SimpleTable, column?: string): void;
-//# sourceMappingURL=flipCoordinates.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"flipCoordinates.d.ts","sourceRoot":"","sources":["../../src/methods/flipCoordinates.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,WAAW,EAAE,WAAW,EACxB,MAAM,CAAC,EAAE,MAAM,QAqBhB"}

package/esm/methods/flipCoordinates.js

@@ -1,22 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
-import queueOp from "../helpers/queueOp.js";
-export default function flipCoordinates(simpleTable, column) {
-    queueOp(simpleTable, {
-        kind: "fusable",
-        method: "flipCoordinates()",
-        parameters: { column },
-        needsSchema: true,
-        needsSpatial: true,
-        // The cast pins the geometry column back to its existing type, so the
-        // schema is unchanged.
-        preservesSchema: true,
-        buildSelect: (input, types) => {
-            const col = column ??
-                findGeoColumnFromSchema(types, "flipCoordinates()", simpleTable.name);
-            // The schema type carries the projection (e.g. GEOMETRY('EPSG:4326')),
-            // so the cast keeps it on the new geometries.
-            return `SELECT * REPLACE (ST_FlipCoordinates(${quoteIdentifier(col)})::${types[col]} AS ${quoteIdentifier(col)}) FROM ${input}`;
-        },
-    });
-}

package/esm/methods/fuzzyClean.d.ts

@@ -1,7 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function fuzzyClean(table: SimpleTable, column: string, newColumn: string, threshold: number, options?: {
-    method?: "ratio" | "partial_ratio" | "token_sort_ratio" | "token_set_ratio";
-    strategy?: "mostCommon" | "longestString" | "shortestString" | "mostCentral" | "maxScore";
-    prefilterPrefixLength?: number;
-}): void;
-//# sourceMappingURL=fuzzyClean.d.ts.map

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

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

package/esm/methods/fuzzyClean.js

@@ -1,94 +0,0 @@
-import quoteIdentifier from "../helpers/quoteIdentifier.js";
-import { DuckDBListValue } from "@duckdb/node-api";
-import mergeOptions from "../helpers/mergeOptions.js";
-import queryDB from "../helpers/queryDB.js";
-import queueOp from "../helpers/queueOp.js";
-import buildFuzzyMatchSql from "../helpers/buildFuzzyMatchSql.js";
-import selectFuzzyReplacements from "../helpers/selectFuzzyReplacements.js";
-export default function fuzzyClean(table, column, newColumn, threshold, options = {}) {
-    // This implementation clusters fuzzy pairs in JS and writes the mapping
-    // back to DuckDB, so it executes as a barrier.
-    options = structuredClone(options);
-    queueOp(table, {
-        kind: "barrier",
-        method: "fuzzyClean()",
-        parameters: { column, newColumn, threshold, options },
-        execute: () => executeFuzzyClean(table, column, newColumn, threshold, options),
-    });
-}
-async function executeFuzzyClean(table, column, newColumn, threshold, options = {}) {
-    const method = options.method ?? "ratio";
-    const strategy = options.strategy ?? "mostCommon";
-    const { scoreExpression, condition } = buildFuzzyMatchSql("a.value", "b.value", method, threshold, { prefilterPrefixLength: options.prefilterPrefixLength });
-    // Compute fuzzy pairs and embed counts for both sides. Only values that
-    // appear in at least one pair above the threshold can be normalized —
-    // singletons need no processing at all.
-    const pairsData = await queryDB(table, `INSTALL rapidfuzz FROM community; LOAD rapidfuzz;
-     WITH uniques AS (
-       SELECT ${quoteIdentifier(column)} AS value, COUNT(*) AS cnt
-       FROM ${quoteIdentifier(table.name)}
-       WHERE ${quoteIdentifier(column)} IS NOT NULL
-       GROUP BY ${quoteIdentifier(column)}
-     )
-     SELECT
-       a.value AS left_value,
-       b.value AS right_value,
-       a.cnt   AS left_cnt,
-       b.cnt   AS right_cnt,
-       ${scoreExpression} AS score
-     FROM uniques a
-     JOIN uniques b
-       ON ${condition}
-       AND a.value < b.value`, mergeOptions(table, {
-        table: table.name,
-        method: "fuzzyClean()",
-        parameters: { column, newColumn, threshold, options },
-        returnData: true,
-    }));
-    const pairs = pairsData ?? [];
-    if (pairs.length === 0) {
-        if (newColumn !== column) {
-            await queryDB(table, `ALTER TABLE ${quoteIdentifier(table.name)} ADD ${quoteIdentifier(newColumn)} VARCHAR;
-         UPDATE ${quoteIdentifier(table.name)}
-           SET ${quoteIdentifier(newColumn)} = ${quoteIdentifier(column)};`, mergeOptions(table, {
-                table: table.name,
-                method: "fuzzyClean()",
-                parameters: { column, newColumn, threshold, options },
-            }));
-        }
-        return;
-    }
-    const replacement = selectFuzzyReplacements(pairs, strategy);
-    if (replacement.size === 0)
-        return;
-    // Two bound lists keep the SQL and parameter count fixed as the mapping
-    // grows. Side-by-side UNNEST zips the equally sized lists into mapping rows,
-    // which DuckDB can hash-join to the original table.
-    const values = [
-        new DuckDBListValue([...replacement.keys()]),
-        new DuckDBListValue([...replacement.values()]),
-    ];
-    const mapping = `WITH mapping(original, canonical) AS (
-    SELECT UNNEST(?::VARCHAR[]), UNNEST(?::VARCHAR[])
-  )`;
-    const query = newColumn !== column
-        ? `ALTER TABLE ${quoteIdentifier(table.name)} ADD ${quoteIdentifier(newColumn)} VARCHAR;
-       UPDATE ${quoteIdentifier(table.name)}
-         SET ${quoteIdentifier(newColumn)} = ${quoteIdentifier(column)};
-       ${mapping}
-       UPDATE ${quoteIdentifier(table.name)}
-         SET ${quoteIdentifier(newColumn)} = m.canonical
-         FROM mapping m
-         WHERE ${quoteIdentifier(table.name)}.${quoteIdentifier(newColumn)} = m.original`
-        : `${mapping}
-       UPDATE ${quoteIdentifier(table.name)}
-         SET ${quoteIdentifier(column)} = m.canonical
-         FROM mapping m
-         WHERE ${quoteIdentifier(table.name)}.${quoteIdentifier(column)} = m.original`;
-    await queryDB(table, query, mergeOptions(table, {
-        table: table.name,
-        method: "fuzzyClean()",
-        parameters: { column, newColumn, options },
-        values,
-    }));
-}

package/esm/methods/fuzzyJoin.d.ts

@@ -1,8 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export default function fuzzyJoin(leftTable: SimpleTable, rightTable: SimpleTable, leftColumn: string, rightColumn: string, threshold: number, options?: {
-    method?: "ratio" | "partial_ratio" | "token_sort_ratio" | "token_set_ratio";
-    similarityColumn?: string;
-    outputTable?: string | boolean;
-    prefilterPrefixLength?: number;
-}): SimpleTable;
-//# sourceMappingURL=fuzzyJoin.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"fuzzyJoin.d.ts","sourceRoot":"","sources":["../../src/methods/fuzzyJoin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAUvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,SAAS,EAAE,WAAW,EACtB,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,MAAM,CAAC,EACH,OAAO,GACP,eAAe,GACf,kBAAkB,GAClB,iBAAiB,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAC3B,GACL,WAAW,CAyCb"}