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

package/script/methods/topologicalSort.d.ts

@@ -0,0 +1,7 @@
+import type SimpleTable from "../class/SimpleTable.js";
+type TopologicalSortOptions = {
+    outputTable?: string | boolean;
+};
+export default function topologicalSort(simpleTable: SimpleTable, sourceColumn: string, targetColumn: string, options?: TopologicalSortOptions): SimpleTable;
+export {};
+//# sourceMappingURL=topologicalSort.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"topologicalSort.d.ts","sourceRoot":"","sources":["../../src/methods/topologicalSort.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAQvD,KAAK,sBAAsB,GAAG;IAC5B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,sBAA2B,GACnC,WAAW,CAoDb"}

package/script/methods/topologicalSort.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = topologicalSort;
+const buildWeakGraphComponentsSql_js_1 = __importDefault(require("../helpers/buildWeakGraphComponentsSql.js"));
+const getGraphEndpointColumns_js_1 = __importDefault(require("../helpers/getGraphEndpointColumns.js"));
+const prepareGraphTraversal_js_1 = require("../helpers/prepareGraphTraversal.js");
+const queueGraphResult_js_1 = __importDefault(require("../helpers/queueGraphResult.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+function topologicalSort(simpleTable, sourceColumn, targetColumn, options = {}) {
+    if (typeof sourceColumn !== "string") {
+        throw new TypeError("topologicalSort() sourceColumn must be a string.");
+    }
+    if (typeof targetColumn !== "string") {
+        throw new TypeError("topologicalSort() targetColumn must be a string.");
+    }
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+        throw new TypeError("topologicalSort() options must be an object.");
+    }
+    if (options.outputTable !== undefined &&
+        typeof options.outputTable !== "string" &&
+        typeof options.outputTable !== "boolean") {
+        throw new TypeError("topologicalSort() options.outputTable must be a string or boolean.");
+    }
+    options = structuredClone(options);
+    const parameters = { sourceColumn, targetColumn, options };
+    const result = (0, queueGraphResult_js_1.default)(simpleTable, {
+        method: "topologicalSort()",
+        parameters,
+        outputTable: options.outputTable,
+        values: (schema) => {
+            validateEndpoints(schema, sourceColumn, targetColumn);
+            return [];
+        },
+        buildSelect: (input, schema) => topologicalSortSelect(input, schema, sourceColumn, targetColumn),
+        outputSchema: (schema) => ({
+            node: validateEndpoints(schema, sourceColumn, targetColumn).idType,
+            componentId: "BIGINT",
+            order: "BIGINT",
+        }),
+    });
+    // Materialize the sorting computation before downstream operations: DuckDB
+    // can otherwise discard even its terminal cycle check for LIMIT 0 or FALSE.
+    // This barrier adds no query or separate validation traversal, and upstream
+    // preparation still fuses into the sorting statement.
+    (0, queueOp_js_1.default)(result, {
+        kind: "barrier",
+        method: "topologicalSort()",
+        parameters,
+        execute: () => Promise.resolve(),
+    });
+    return result;
+}
+function validateEndpoints(schema, source, target) {
+    return (0, getGraphEndpointColumns_js_1.default)(schema, source, target, "topologicalSort()");
+}
+function topologicalSortSelect(input, schema, source, target) {
+    const prepared = (0, prepareGraphTraversal_js_1.prepareGraphSql)(input, schema, source, target, "topologicalSort()");
+    const relations = prepared.relationNames([
+        "graph_edges",
+        "graph_nodes",
+        "graph_topological_order",
+        "graph_topological_result",
+        "graph_component_edges",
+        "graph_component_labels",
+        "graph_component_roots",
+        "graph_ordered_nodes",
+    ]);
+    const edges = relations.graph_edges;
+    const nodes = relations.graph_nodes;
+    const ordering = relations.graph_topological_order;
+    const result = relations.graph_topological_result;
+    const componentEdges = relations.graph_component_edges;
+    const labels = relations.graph_component_labels;
+    const roots = relations.graph_component_roots;
+    const orderedNodes = relations.graph_ordered_nodes;
+    const q = quoteIdentifier_js_1.default;
+    return `WITH RECURSIVE ${edges} AS (
+      ${prepared.edges("outgoing")}
+    ), ${nodes} AS (
+      SELECT ${q("__from")} AS ${q("node")},
+        ${q("__from_key")} AS ${q("__key")}
+      FROM ${edges}
+      UNION
+      SELECT ${q("__to")} AS ${q("node")},
+        ${q("__to_key")} AS ${q("__key")}
+      FROM ${edges}
+    ), ${componentEdges} AS (
+      SELECT * FROM ${edges}
+      UNION ALL
+      SELECT ${q("__to")}, ${q("__from")},
+        ${q("__to_key")}, ${q("__from_key")}
+      FROM ${edges}
+    ), ${(0, buildWeakGraphComponentsSql_js_1.default)(componentEdges, nodes, labels, roots)},
+    ${ordering}(
+      ${q("node")}, ${q("__key")}, ${q("order")}, ${q("__ordered")}
+    ) AS (
+      SELECT ${q("eligible")}.${q("node")},
+        ${q("eligible")}.${q("__key")}, CAST(1 AS BIGINT),
+        list_value(${q("eligible")}.${q("__key")})
+      FROM (
+        SELECT ${q("candidate")}.${q("node")},
+          ${q("candidate")}.${q("__key")}
+        FROM ${nodes} AS ${q("candidate")}
+        WHERE NOT EXISTS (
+          SELECT 1 FROM ${edges} AS ${q("edge")}
+          WHERE ${q("edge")}.${q("__to_key")} =
+            ${q("candidate")}.${q("__key")}
+        )
+        ORDER BY ${q("candidate")}.${q("__key")}
+        LIMIT 1
+      ) AS ${q("eligible")}
+      UNION ALL
+      SELECT ${q("eligible")}.${q("node")},
+        ${q("eligible")}.${q("__key")},
+        ${q("ordered")}.${q("order")} + 1,
+        list_append(
+          ${q("ordered")}.${q("__ordered")},
+          ${q("eligible")}.${q("__key")}
+        )
+      FROM ${ordering} AS ${q("ordered")}
+      CROSS JOIN LATERAL (
+        SELECT ${q("candidate")}.${q("node")},
+          ${q("candidate")}.${q("__key")}
+        FROM ${nodes} AS ${q("candidate")}
+        WHERE NOT list_contains(
+          ${q("ordered")}.${q("__ordered")},
+          ${q("candidate")}.${q("__key")}
+        )
+          AND NOT EXISTS (
+            SELECT 1 FROM ${edges} AS ${q("edge")}
+            WHERE ${q("edge")}.${q("__to_key")} =
+                ${q("candidate")}.${q("__key")}
+              AND NOT list_contains(
+                ${q("ordered")}.${q("__ordered")},
+                ${q("edge")}.${q("__from_key")}
+              )
+          )
+        ORDER BY ${q("candidate")}.${q("__key")}
+        LIMIT 1
+      ) AS ${q("eligible")}
+    ), ${result} AS (
+      SELECT CASE WHEN count(*) < (SELECT count(*) FROM ${nodes})
+        THEN error(
+          'topologicalSort() cannot order the graph because it contains a directed cycle.'
+        )
+        ELSE list(${q("node")} ORDER BY ${q("order")})
+      END AS ${q("__nodes")}
+      FROM ${ordering}
+    ), ${orderedNodes} AS (
+      SELECT unnest(${q("__nodes")}) AS ${q("node")},
+        generate_subscripts(${q("__nodes")}, 1) AS ${q("__order")}
+      FROM ${result}
+    )
+    SELECT ${q("ordered")}.${q("node")}, ${q("roots")}.${q("componentId")},
+      row_number() OVER (
+        PARTITION BY ${q("roots")}.${q("componentId")}
+        ORDER BY ${q("ordered")}.${q("__order")}
+      ) AS ${q("order")}
+    FROM ${orderedNodes} AS ${q("ordered")}
+    INNER JOIN ${labels} AS ${q("labels")}
+      ON ${prepared.key(`${q("ordered")}.${q("node")}`)} =
+        ${q("labels")}.${q("__node_key")}
+    INNER JOIN ${roots} AS ${q("roots")}
+      ON ${q("labels")}.${q("__root_key")} = ${q("roots")}.${q("__root_key")}
+    ORDER BY ${q("componentId")}, ${q("order")}`;
+}

package/script/methods/trim.d.ts

@@ -1,5 +1,5 @@
 import type SimpleTable from "../class/SimpleTable.js";
-export default function trim(simpleTable: SimpleTable, columns: string | string[], options?: {
+export default function trim(simpleTable: SimpleTable, columns: "all" | string | string[], options?: {
     character?: string;
     side?: "left" | "right" | "both";
 }): void;

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

@@ -1 +1 @@
-{"version":3,"file":"trim.d.ts","sourceRoot":"","sources":["../../src/methods/trim.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAC1B,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;CAC7B,QAuCP"}
+{"version":3,"file":"trim.d.ts","sourceRoot":"","sources":["../../src/methods/trim.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,EAAE,EAClC,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;CAC7B,QAgDP"}

package/script/methods/trim.js

@@ -8,7 +8,9 @@ const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier
 const stringToArray_js_1 = __importDefault(require("../helpers/stringToArray.js"));
 const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
 function trim(simpleTable, columns, options = {}) {
-    const cols = (0, stringToArray_js_1.default)(columns);
+    const cols = columns === "all" ? null : (0, stringToArray_js_1.default)(columns);
+    const resolveColumns = (schema) => cols ??
+        Object.keys(schema).filter((column) => schema[column] === "VARCHAR");
     const side = options.side ?? "both";
     const fn = side === "left"
         ? "LTRIM"
@@ -20,17 +22,24 @@ function trim(simpleTable, columns, options = {}) {
     if (fn === null) {
         throw new Error(`trim() options.side must be "left", "right", or "both". Received ${JSON.stringify(options.side)}.`);
     }
-    const specialCharacter = typeof options.character === "string" ? ", ?" : "";
+    const character = options.character;
+    const specialCharacter = typeof character === "string" ? ", ?" : "";
     (0, queueOp_js_1.default)(simpleTable, {
         kind: "fusable",
         method: "trim()",
         parameters: { columns, options },
-        values: typeof options.character === "string"
-            ? cols.map(() => options.character)
+        values: typeof character === "string"
+            ? (schema) => resolveColumns(schema).map(() => character)
             : undefined,
-        needsSchema: false,
-        buildSelect: (input) => `SELECT * REPLACE (${cols
-            .map((c) => `${fn}(${(0, quoteIdentifier_js_1.default)(c)}${specialCharacter}) AS ${(0, quoteIdentifier_js_1.default)(c)}`)
-            .join(", ")}) FROM ${input}`,
+        needsSchema: columns === "all",
+        buildSelect: (input, schema) => {
+            const selectedColumns = resolveColumns(schema);
+            if (columns === "all" && selectedColumns.length === 0) {
+                return `SELECT * FROM ${input}`;
+            }
+            return `SELECT * REPLACE (${selectedColumns
+                .map((c) => `${fn}(${(0, quoteIdentifier_js_1.default)(c)}${specialCharacter}) AS ${(0, quoteIdentifier_js_1.default)(c)}`)
+                .join(", ")}) FROM ${input}`;
+        },
     });
 }