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

package/src/helpers/printTable.ts

@@ -0,0 +1,264 @@
+import LogValue from "./LogValue.ts";
+import splitGraphemes from "./splitGraphemes.ts";
+import wrapString from "./wrapString.ts";
+
+/**
+ * Prints a formatted table to the console with support for word wrapping
+ * within headers and cells. Unlike `console.table()`, this function properly
+ * handles multi-line content, making it ideal for displaying data with long
+ * column names and text values.
+ * Widths count graphemes, keeping combining accents with their letters. Wide
+ * characters and emoji are not measured by their terminal display width.
+ *
+ * @example
+ * ```typescript
+ * const data = [
+ *   { name: "Alice", description: "A software engineer with expertise in TypeScript" },
+ *   { name: "Bob", description: "A product manager" }
+ * ];
+ * printTable(data, { maxColumnWidth: 30 });
+ * // Outputs a nicely formatted table with word-wrapped description column
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With types row
+ * const types = { name: "VARCHAR/string", age: "INTEGER/number" };
+ * const data = [
+ *   { name: "Alice", age: 30 },
+ *   { name: "Bob", age: 25 }
+ * ];
+ * printTable([types, ...data], { typesRowIndex: 0 });
+ * ```
+ *
+ * @param data - An array of objects representing the rows of the table. Each
+ *   object should have string keys.
+ *
+ * @param options - Optional configuration for table rendering.
+ *
+ * @param options.maxColumnWidth - The maximum width for any column (default:
+ *   `75`). Headers and values exceeding this width will be wrapped at word
+ *   boundaries.
+ *
+ * @param options.minColumnWidth - The minimum width for any column (default:
+ *   `3`).
+ *
+ * @param options.typesRowIndex - The index of a row that contains type
+ *   annotations (e.g. `"VARCHAR/string"`). This row will be rendered in grey.
+ *   If omitted, no row is treated as a types row.
+ *
+ * @returns void - The table is printed directly to the console.
+ */
+export default function printTable(
+  data: { [key: string]: unknown }[],
+  options?: {
+    maxColumnWidth?: number;
+    minColumnWidth?: number;
+    typesRowIndex?: number;
+  },
+): void {
+  if (!data || data.length === 0) {
+    console.log("(empty table)");
+    return;
+  }
+
+  const maxColumnWidth = options?.maxColumnWidth ?? 75;
+  const minColumnWidth = options?.minColumnWidth ?? 3;
+
+  // Helper function to format values for display
+  const formatValue = (value: unknown): string => {
+    if (value instanceof LogValue) return value.text;
+    if (value instanceof Date) {
+      return Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
+    }
+    return String(value);
+  };
+
+  // Get all column names
+  const columns = Object.keys(data[0]);
+
+  if (columns.length === 0) {
+    console.log("(empty table)");
+    return;
+  }
+
+  // Single pass: calculate column widths and prepare wrapped data.
+  // First, seed widths from header names.
+  const columnWidths: { [key: string]: number } = {};
+  for (const col of columns) {
+    columnWidths[col] = Math.max(...col.split("\n").map((line) => splitGraphemes(line).length));
+  }
+
+  // Format every cell, track the longest raw line per column, and
+  // store the formatted strings for the wrapping step that follows.
+  const formattedData: string[][] = [];
+  for (const row of data) {
+    const formattedRow: string[] = [];
+    for (let c = 0; c < columns.length; c++) {
+      const col = columns[c];
+      const value = formatValue(row[col]);
+      formattedRow.push(value);
+
+      // Track longest line (handles embedded newlines)
+      const lines = value.split("\n");
+      let longestLine = 0;
+      for (const line of lines) {
+        const length = splitGraphemes(line).length;
+        if (length > longestLine) longestLine = length;
+      }
+      if (longestLine > columnWidths[col]) {
+        columnWidths[col] = longestLine;
+      }
+    }
+    formattedData.push(formattedRow);
+  }
+
+  // Apply min/max constraints
+  for (const col of columns) {
+    columnWidths[col] = Math.min(Math.max(columnWidths[col], minColumnWidth), maxColumnWidth);
+  }
+
+  // Use the same newline and word wrapping rules for headers and cells.
+  const wrapCell = (value: string, width: number): string[] => {
+    const lines = value
+      .split("\n")
+      .flatMap((line) =>
+        splitGraphemes(line).length <= width ? [line] : wrapString(line, width).split("\n"),
+      );
+    return lines.length > 0 ? lines : [""];
+  };
+  const wrappedHeaders = columns.map((col) => wrapCell(col, columnWidths[col]));
+  const wrappedData = formattedData.map((row) =>
+    Object.fromEntries(columns.map((col, c) => [col, wrapCell(row[c], columnWidths[col])])),
+  );
+
+  // ANSI console color codes
+  const colors = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    grey: "\x1b[90m",
+    string: "\x1b[32m", // green
+    number: "\x1b[33m", // yellow
+    boolean: "\x1b[95m", // bright magenta/pink
+    date: "\x1b[36m", // cyan
+    null: "\x1b[90m", // grey
+  };
+
+  // Helper function to get color for a value based on its actual JavaScript type
+  const getColorForValue = (value: unknown, isTypeRow: boolean): string => {
+    if (isTypeRow) return colors.grey;
+    if (value instanceof LogValue) return colors[value.category];
+    if (value === null || value === undefined) return colors.null;
+    if (value instanceof Date) return colors.date;
+    if (typeof value === "boolean") return colors.boolean;
+    if (typeof value === "number") return colors.number;
+    return colors.string;
+  };
+
+  // Helper function to create a horizontal border line with column junctions
+  const createBorderLine = (left: string, middle: string, right: string) => {
+    const segments = columns.map((col) => "─".repeat(columnWidths[col] + 2));
+    return colors.grey + left + segments.join(middle) + right + colors.reset;
+  };
+
+  // Helper function to create a separator line
+  const createSeparator = () => createBorderLine("├", "┼", "┤");
+
+  // Helper function to create the top border
+  const createTopBorder = () => createBorderLine("┌", "┬", "┐");
+
+  // Helper function to create the bottom border
+  const createBottomBorder = () => createBorderLine("└", "┴", "┘");
+
+  // Helper function to pad a string to a specific width
+  const pad = (str: string, width: number) => {
+    return str + " ".repeat(Math.max(0, width - splitGraphemes(str).length));
+  };
+
+  // Print top border
+  console.log(createTopBorder());
+
+  // Print each header line in bold, padding shorter headers to the same height.
+  const headerHeight = Math.max(...wrappedHeaders.map((lines) => lines.length));
+  for (let lineIdx = 0; lineIdx < headerHeight; lineIdx++) {
+    const headerParts = columns.map(
+      (col, c) =>
+        ` ${colors.bold}${pad(
+          wrappedHeaders[c][lineIdx] ?? "",
+          columnWidths[col],
+        )}${colors.reset} `,
+    );
+    console.log(
+      colors.grey +
+        "│" +
+        colors.reset +
+        headerParts.join(colors.grey + "│" + colors.reset) +
+        colors.grey +
+        "│" +
+        colors.reset,
+    );
+  }
+
+  // Detect if any row has word wrapping (spans multiple lines)
+  let hasWordWrapping = false;
+  for (const wrappedRow of wrappedData) {
+    for (const col of columns) {
+      if (wrappedRow[col].length > 1) {
+        hasWordWrapping = true;
+        break;
+      }
+    }
+    if (hasWordWrapping) break;
+  }
+
+  // Print separator after header (unless the first row is the types row,
+  // in which case the separator is printed after the types row instead)
+  if (options?.typesRowIndex !== 0) {
+    console.log(createSeparator());
+  }
+
+  // Print data rows
+  for (let i = 0; i < wrappedData.length; i++) {
+    const wrappedRow = wrappedData[i];
+    const originalRow = data[i];
+    const isTypeRow = i === options?.typesRowIndex;
+
+    // Find the maximum number of lines in this row
+    let maxLines = 1;
+    for (const col of columns) {
+      if (wrappedRow[col].length > maxLines) {
+        maxLines = wrappedRow[col].length;
+      }
+    }
+
+    // Print each line of this row
+    for (let lineIdx = 0; lineIdx < maxLines; lineIdx++) {
+      const lineParts = columns.map((col) => {
+        const lines = wrappedRow[col];
+        const lineValue = lineIdx < lines.length ? lines[lineIdx] : "";
+        const color = getColorForValue(originalRow[col], isTypeRow);
+        return ` ${color}${pad(lineValue, columnWidths[col])}${colors.reset} `;
+      });
+      console.log(
+        colors.grey +
+          "│" +
+          colors.reset +
+          lineParts.join(colors.grey + "│" + colors.reset) +
+          colors.grey +
+          "│" +
+          colors.reset,
+      );
+    }
+
+    // Print separator after types row
+    if (isTypeRow) {
+      console.log(createSeparator());
+    } // Print separator between rows when word wrapping is present (except after last row)
+    else if (hasWordWrapping && i < wrappedData.length - 1) {
+      console.log(createSeparator());
+    }
+  }
+
+  // Print bottom border
+  console.log(createBottomBorder());
+}

package/src/helpers/publishPreparedColumns.ts

@@ -0,0 +1,172 @@
+import type SimpleTable from "../class/SimpleTable.ts";
+import type { PreparedNumericFeatures } from "./prepareNumericFeatures.ts";
+import foldIdentifier from "./foldIdentifier.ts";
+import mergeOptions from "./mergeOptions.ts";
+import queryDB from "./queryDB.ts";
+import quoteIdentifier from "./quoteIdentifier.ts";
+
+type PublicationOutput = {
+  /** Raw output-column name. */
+  name: string;
+  /** Trusted internal SQL evaluated with the prepared relation aliased as p. */
+  expression: string;
+  /** Raw source-column name to replace in its original position. */
+  replace?: string;
+};
+
+type PublicationResult = {
+  /** Raw relation name joined to the prepared rows. */
+  relation: string;
+  /** Raw row-identity column in the result relation. */
+  rowIdColumn: string;
+};
+
+/**
+ * Publishes validated algorithm outputs from a prepared numeric
+ * feature snapshot. New outputs are appended, while replacements retain the
+ * source column's position. Existing native DuckDB indexes are recreated after
+ * table replacement because CREATE OR REPLACE drops them.
+ *
+ * Output expressions are trusted internal SQL. They may reference `p`, the
+ * prepared relation alias, and `r` when a result relation is supplied. The
+ * consumer must fully compute and validate one result row per prepared row
+ * before calling this helper, and remains responsible for scratch cleanup.
+ */
+export default async function publishPreparedColumns(
+  table: SimpleTable,
+  prepared: Pick<
+    PreparedNumericFeatures,
+    "relation" | "rowIdColumn" | "sourceColumns" | "sourceTemporary"
+  >,
+  options: {
+    method: string;
+    parameters: { [key: string]: unknown } | null;
+    outputs: PublicationOutput[];
+    result?: PublicationResult;
+  },
+): Promise<void> {
+  validateOutputs(prepared.sourceColumns, options.outputs);
+
+  const connection = table.connection!;
+  const q = quoteIdentifier;
+  const source = q(table.name);
+  const tableDetails = (
+    await connection.runAndReadAll(
+      `SELECT table_oid FROM duckdb_tables()
+     WHERE translate(table_name, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz') = $1
+       AND schema_name = current_schema()
+       AND database_name IN (current_database(), 'temp')
+       AND temporary = $2
+     LIMIT 1`,
+      [foldIdentifier(table.name), prepared.sourceTemporary],
+    )
+  ).getRowsJS()[0];
+  if (tableDetails === undefined) {
+    throw new Error(`${options.method} requires a materialized source table.`);
+  }
+  const tableOid = tableDetails[0];
+  if (typeof tableOid !== "number" && typeof tableOid !== "bigint") {
+    throw new Error(`${options.method} could not identify the source table.`);
+  }
+
+  const indexes = (
+    await connection.runAndReadAll(
+      "SELECT sql FROM duckdb_indexes() WHERE table_oid = $1 ORDER BY index_name",
+      [tableOid],
+    )
+  )
+    .getRowsJS()
+    .map((row) => {
+      if (typeof row[0] !== "string") throw new Error("Expected index SQL to be a string.");
+      return row[0];
+    });
+  const replacements = new Map(
+    options.outputs
+      .filter((output) => output.replace !== undefined)
+      .map((output) => [foldIdentifier(output.replace!), output]),
+  );
+  const select = prepared.sourceColumns.map((column) => {
+    const replacement = replacements.get(foldIdentifier(column));
+    return replacement === undefined
+      ? `p.${q(column)}`
+      : `${replacement.expression} AS ${q(column)}`;
+  });
+  for (const output of options.outputs) {
+    if (output.replace === undefined) {
+      select.push(`${output.expression} AS ${q(output.name)}`);
+    }
+  }
+  const resultJoin =
+    options.result === undefined
+      ? ""
+      : ` JOIN ${q(options.result.relation)} r
+      ON p.${q(prepared.rowIdColumn)} = r.${q(options.result.rowIdColumn)}`;
+
+  await queryDB(
+    table,
+    `CREATE OR REPLACE ${prepared.sourceTemporary ? "TEMP " : ""}TABLE ${source} AS
+     SELECT ${select.join(", ")}
+     FROM ${q(prepared.relation)} p${resultJoin}
+     ORDER BY p.${q(prepared.rowIdColumn)}`,
+    mergeOptions(table, {
+      table: table.name,
+      method: options.method,
+      parameters: options.parameters,
+      noClean: true,
+    }),
+  );
+  for (const sql of indexes) {
+    try {
+      await connection.run(sql);
+    } catch (error) {
+      const detail = error instanceof Error ? ` ${error.message}` : "";
+      throw new Error(
+        `${options.method} could not restore an existing DuckDB index while publishing its output. Remove or rebuild indexes that do not support the output column types.${detail}`,
+        { cause: error },
+      );
+    }
+  }
+}
+
+function validateOutputs(sourceColumns: string[], outputs: PublicationOutput[]): void {
+  const outputNames = new Set<string>();
+  const replacements = new Set<string>();
+  for (const output of outputs) {
+    const outputName = foldIdentifier(output.name);
+    if (outputNames.has(outputName)) {
+      throw new Error(
+        `Internal publication received duplicate output column ${quoteIdentifier(output.name)}.`,
+      );
+    }
+    outputNames.add(outputName);
+    if (output.replace === undefined) {
+      if (sourceColumns.some((column) => foldIdentifier(column) === outputName)) {
+        throw new Error(
+          `Internal publication cannot append existing column ${quoteIdentifier(output.name)}.`,
+        );
+      }
+      continue;
+    }
+    const replacement = foldIdentifier(output.replace);
+    if (outputName !== replacement) {
+      throw new Error(
+        `Internal publication output ${quoteIdentifier(
+          output.name,
+        )} must match its replacement column ${quoteIdentifier(output.replace)}.`,
+      );
+    }
+    if (!sourceColumns.some((column) => foldIdentifier(column) === replacement)) {
+      throw new Error(
+        `Internal publication cannot replace missing column ${quoteIdentifier(output.replace)}.`,
+      );
+    }
+    if (replacements.has(replacement)) {
+      throw new Error(
+        `Internal publication received duplicate replacement column ${quoteIdentifier(
+          output.replace,
+        )}.`,
+      );
+    }
+    replacements.add(replacement);
+  }
+}

package/src/helpers/queryDB.ts

@@ -0,0 +1,116 @@
+import type { DuckDBValue as NativeDuckDBValue } from "@duckdb/node-api";
+import SimpleTable from "../class/SimpleTable.ts";
+import SimpleDB from "../class/SimpleDB.ts";
+import cleanSQL from "./cleanSQL.ts";
+import flushAllTables from "./flushAllTables.ts";
+import { recordCacheTableAccess } from "./cacheTableDependencies.ts";
+
+/** @internal DuckDB owns this type; retain its exact binding contract without re-exporting it. */
+type DuckDBValue = NativeDuckDBValue;
+
+/**
+ * Executes SQL for a table or database after flushing all queued operations.
+ * Starts the database on first use and applies its SQL logging settings.
+ * Extension authors can construct `options` with `mergeOptions()`.
+ *
+ * @example
+ * ```ts
+ * import { mergeOptions, queryDB, quoteIdentifier } from "@nshiab/simple-data-analysis-core/helpers";
+ *
+ * await table.loadArray([{ answer: 0 }]).run();
+ * const query = `UPDATE ${quoteIdentifier(table.name)} SET answer = ?`;
+ * await queryDB(table, query, mergeOptions(table, {
+ *   table: table.name,
+ *   method: "example()",
+ *   parameters: null,
+ *   values: [42],
+ * }));
+ * await table.log();
+ * ```
+ *
+ * @param simple - The table or database that owns the query.
+ *
+ * @param query - The SQL statement to execute.
+ *
+ * @param options - Query execution and diagnostic settings.
+ *
+ * @param options.table - The table name used for diagnostics, or `null`.
+ *
+ * @param options.method - The calling method used for diagnostics, or `null`.
+ *
+ * @param options.parameters - Arguments included in error diagnostics, or `null`.
+ *
+ * @param options.rowsToLog - The caller's row-display limit, retained for compatibility.
+ *
+ * @param options.charsToLog - The caller's per-cell display limit, retained for compatibility.
+ *
+ * @param options.returnData - Whether to convert and return the result rows.
+ *
+ * @param options.values - DuckDB-native values bound to SQL placeholders, in order.
+ *
+ * @param options.noClean - Whether to preserve the SQL text without cleaning it.
+ *
+ * @returns Converted rows when `returnData` is true, otherwise `null`.
+ */
+export default async function queryDB(
+  simple: SimpleTable | SimpleDB,
+  query: string,
+  options: {
+    table: string | null;
+    method: string | null;
+    parameters: { [key: string]: unknown } | null;
+    rowsToLog: number;
+    charsToLog: number | undefined;
+    returnData: boolean;
+    values?: DuckDBValue[];
+    noClean?: boolean;
+  },
+): Promise<
+  | {
+      [key: string]: unknown;
+    }[]
+  | null
+> {
+  if (simple instanceof SimpleTable) {
+    recordCacheTableAccess(simple);
+  }
+  const sdb = simple instanceof SimpleTable ? simple.sdb : simple;
+  if (sdb.lifecycleState === "closed") {
+    throw new Error(`${options.method ?? "The query"} cannot run because its SimpleDB is closed.`);
+  }
+  if (simple instanceof SimpleDB && simple.connection === undefined) {
+    await simple.start();
+  } else if (simple instanceof SimpleTable && simple.connection === undefined) {
+    await simple.sdb.start();
+    simple.db = simple.sdb.db;
+    simple.connection = simple.sdb.connection;
+  }
+  if (simple.connection === undefined) {
+    throw new Error("simple.connection is undefined");
+  }
+
+  // Observing executes: any query touching the database first flushes the
+  // operations queued by sync builder methods, preserving program order.
+  await flushAllTables(simple instanceof SimpleTable ? simple.sdb : simple);
+
+  if (options.noClean !== true) {
+    query = cleanSQL(query, sdb.expressionSyntax);
+  }
+
+  const executionOptions = {
+    ...options,
+    logSQL: sdb.logSQL,
+    explainSQL: sdb.explainSQL,
+  };
+
+  if (options.returnData) {
+    const data = await simple.runQuery(query, simple.connection, true, executionOptions);
+    if (data === null) {
+      throw new Error("data is null");
+    }
+    return data;
+  } else {
+    await simple.runQuery(query, simple.connection, false, executionOptions);
+    return null;
+  }
+}

package/src/helpers/queryDbFile.ts

@@ -0,0 +1,22 @@
+import type SimpleDB from "../class/SimpleDB.ts";
+import queryDB from "./queryDB.ts";
+import mergeOptions from "./mergeOptions.ts";
+
+/** Executes generated database-file SQL without rewriting paths or metadata. */
+export default function queryDbFile(
+  sdb: SimpleDB,
+  sql: string,
+  options: { returnData?: boolean } = {},
+) {
+  return queryDB(
+    sdb,
+    sql,
+    mergeOptions(sdb, {
+      table: null,
+      method: "database file operation",
+      parameters: null,
+      returnData: options.returnData,
+      noClean: true,
+    }),
+  );
+}

package/src/helpers/queueAsyncBarrier.ts

@@ -0,0 +1,63 @@
+import type SimpleTable from "../class/SimpleTable.ts";
+import queueOp from "./queueOp.ts";
+
+/**
+ * Queues asynchronous extension work as one ordered table-builder step.
+ * Builder operations queued by `execute` are scoped to the barrier and drain
+ * before its observer queries and before later chained operations.
+ *
+ * `execute` must await all asynchronous work that can queue table operations.
+ * Detached work is outside the barrier's program-order scope.
+ *
+ * If `execute` rejects, captured builder operations that have not already
+ * drained are discarded. Operations drained by an observer inside `execute`
+ * remain applied; an asynchronous barrier does not provide database rollback.
+ *
+ * This differs from a failure while executing queued builders: during replay,
+ * the failing table's remaining chain is aborted, but unexecuted work for other
+ * tables is requeued for their next observation.
+ *
+ * @example
+ * ```ts
+ * import type { SimpleTable } from "@nshiab/simple-data-analysis-core";
+ * import { queueAsyncBarrier } from "@nshiab/simple-data-analysis-core/helpers";
+ *
+ * function loadRemote(table: SimpleTable, url: string): SimpleTable {
+ *   queueAsyncBarrier(table, {
+ *     method: "loadRemote()",
+ *     parameters: { url },
+ *     execute: async () => {
+ *       const rows = await fetch(url).then((response) => response.json()) as
+ *         { [key: string]: unknown }[];
+ *       table.loadArray(rows);
+ *     },
+ *   });
+ *   return table;
+ * }
+ * ```
+ *
+ * @param simpleTable - The table whose chain owns the asynchronous work.
+ *
+ * @param operation - The asynchronous extension operation to queue.
+ *
+ * @param operation.method - The public method name used for diagnostics.
+ *
+ * @param operation.parameters - A snapshot of the public method parameters used for diagnostics.
+ *
+ * @param operation.execute - The asynchronous work to run at the barrier's position in the chain.
+ *
+ * @returns Nothing. The public builder should return its target table.
+ */
+export default function queueAsyncBarrier(
+  simpleTable: SimpleTable,
+  operation: {
+    method: string;
+    parameters: { [key: string]: unknown } | null;
+    execute: () => Promise<void>;
+  },
+): void {
+  queueOp(simpleTable, {
+    kind: "asyncBarrier",
+    ...operation,
+  });
+}

package/src/helpers/queueGraphResult.ts

@@ -0,0 +1,58 @@
+import type { DuckDBValue } from "@duckdb/node-api";
+import type SimpleTable from "../class/SimpleTable.ts";
+import type { TableSchema } from "./pendingOps.ts";
+import queueOp from "./queueOp.ts";
+import quoteIdentifier from "./quoteIdentifier.ts";
+import resolveOutputTable from "./resolveOutputTable.ts";
+
+type GraphResult = {
+  buildSelect: (input: string, schema: TableSchema) => string;
+  method: string;
+  outputSchema: (schema: TableSchema) => TableSchema;
+  outputTable?: string | boolean;
+  parameters: { [key: string]: unknown };
+  preflight?: (input: SimpleTable) => Promise<void>;
+  values: (schema: TableSchema) => DuckDBValue[];
+};
+
+/** Queues a graph SELECT for overwrite or a source-preserving output table. */
+export default function queueGraphResult(
+  simpleTable: SimpleTable,
+  result: GraphResult,
+): SimpleTable {
+  const resolvedOutput = resolveOutputTable(simpleTable, result.outputTable);
+  const outputTable =
+    typeof resolvedOutput === "string" ? simpleTable.sdb.newTable(resolvedOutput) : simpleTable;
+
+  if (outputTable !== simpleTable) {
+    queueOp(outputTable, {
+      kind: "source",
+      method: result.method,
+      parameters: result.parameters,
+      rawSQL: [quoteIdentifier(simpleTable.name)],
+      buildSelect: () => `SELECT * FROM ${quoteIdentifier(simpleTable.name)}`,
+    });
+  }
+
+  // A separate barrier keeps invalid-event checks observable after LIMIT 0.
+  const preflight = result.preflight;
+  if (preflight !== undefined) {
+    queueOp(outputTable, {
+      kind: "barrier",
+      method: result.method,
+      parameters: result.parameters,
+      execute: () => preflight(outputTable),
+    });
+  }
+
+  queueOp(outputTable, {
+    kind: "fusable",
+    method: result.method,
+    parameters: result.parameters,
+    needsSchema: true,
+    values: result.values,
+    buildSelect: result.buildSelect,
+    outputSchema: result.outputSchema,
+  });
+  return outputTable;
+}