@terascope/data-mate 2.24.0 → 2.25.1

package/dist/src/teal-frame/DuckContext.js

@@ -0,0 +1,244 @@
+import { DuckDBInstance } from '@duckdb/node-api';
+import { resolve } from 'node:path';
+import { quoteLiteral } from '@terascope/sql-builder';
+import { createScalarFunction } from './scalar-function.js';
+import { toPlainValue } from './plain-values.js';
+import { extensionSettingsFromEnv, loadExtensions } from './extensions.js';
+/** DuckDB's hard per-chunk row limit. Appending more in one chunk throws. */
+export const MAX_CHUNK_ROWS = 2048;
+/**
+ * Owns a DuckDB instance and its shared connection.
+ *
+ * Internal: it is not exported from the package, and callers reach the database through
+ * `configureDuckDatabase`, `registerScalarFunction` and `closeDuckDatabase`. Processes that
+ * need to exchange data hand each other Parquet files rather than sharing a database.
+ *
+ * Every frame on a database shares the instance, because tables live in its catalog and any
+ * connection can see them (they are real tables, not TEMP tables, which would be
+ * connection-local). Streams do not share the connection; see `streamRowObjects`.
+*/
+export class DuckContext {
+    instance;
+    connection;
+    path;
+    extensionDirectory;
+    /**
+     * Registered scalar functions, kept so they are not garbage-collected while DuckDB still
+     * holds them, and so a name cannot be silently registered twice.
+    */
+    functions = new Map();
+    constructor(instance, connection, 
+    /** The database path, so a frame can report where it lives. */
+    path, 
+    /** Fixed for the instance's life - DuckDB resolves extensions from it at LOAD. */
+    extensionDirectory) {
+        this.instance = instance;
+        this.connection = connection;
+        this.path = path;
+        this.extensionDirectory = extensionDirectory;
+    }
+    /**
+     * Registers a scalar function on the instance.
+     *
+     * Registration is instance-wide: a function registered on one connection is visible to
+     * every other connection, including the private connection each stream opens. That is
+     * what lets UDFs and streaming work together.
+    */
+    registerFunction(spec) {
+        // Idempotent: `tealFrameAdapter` derives the name from (function, column, args), so
+        // a second registration under the same name is the same function and must not error.
+        if (this.functions.has(spec.name))
+            return;
+        const fn = createScalarFunction(spec);
+        this.connection.registerScalarFunction(fn);
+        this.functions.set(spec.name, fn);
+    }
+    /** How many scalar functions are registered. They cannot be removed, so keep this bounded. */
+    get functionCount() {
+        return this.functions.size;
+    }
+    hasFunction(name) {
+        return this.functions.has(name);
+    }
+    /**
+     * Opens the database and loads the required extensions, so a missing extension fails at
+     * startup rather than at the first query that needs it (see `extensions.ts`).
+     *
+     * Explicit settings take precedence over the environment. On failure the instance is
+     * closed, because nothing else holds it and it would otherwise leak.
+    */
+    static async create(path = ':memory:', settings = {}) {
+        const extensions = resolveExtensionSettings(settings);
+        const instance = await DuckDBInstance.create(path, instanceOptions(extensions));
+        let connection;
+        try {
+            connection = await instance.connect();
+            const context = new DuckContext(instance, connection, path, extensions.extensionDirectory);
+            await context.applySettings(settings);
+            await loadExtensions(connection, extensions.autoinstallExtensions ?? true);
+            return context;
+        }
+        catch (err) {
+            // Close both, as `disconnect()` does: a live connection keeps a closed instance open
+            connection?.disconnectSync();
+            instance.closeSync();
+            throw err;
+        }
+    }
+    /**
+     * Applies the spill, memory and thread settings. They are runtime `SET`s, so they can be
+     * changed on an open database.
+     *
+     * Without `temp_directory`, a query that exceeds `memory_limit` fails instead of spilling
+     * to disk.
+     *
+     * **Set `memory_limit` below the container's memory cap.** If DuckDB thinks it has more
+     * memory than the container allows, it never spills and the kernel kills the process.
+    */
+    async applySettings(settings) {
+        // Refused rather than applied: extensions already loaded from the old directory stay
+        // loaded, so the new value would be reported but never used. Paths are compared after
+        // resolving, so `/ext/` and `/ext` count as the same directory.
+        if (settings.extensionDirectory != null
+            && !sameDirectory(settings.extensionDirectory, this.extensionDirectory)) {
+            throw new Error(`extensionDirectory is fixed once the database opens - "${this.path}" opened`
+                + ` with ${this.extensionDirectory ?? 'the default'}, so`
+                + ` "${settings.extensionDirectory}" cannot take effect. Set`
+                + ` DUCKDB_EXTENSION_DIRECTORY, or configure before the first frame.`);
+        }
+        if (settings.autoinstallExtensions != null) {
+            await this.run(`SET autoinstall_known_extensions = ${settings.autoinstallExtensions}`);
+        }
+        if (settings.tempDirectory != null) {
+            await this.run(`SET temp_directory = ${quoteLiteral(settings.tempDirectory)}`);
+        }
+        if (settings.maxTempDirectorySize != null) {
+            await this.run(`SET max_temp_directory_size = ${quoteLiteral(settings.maxTempDirectorySize)}`);
+        }
+        if (settings.memoryLimit != null) {
+            await this.run(`SET memory_limit = ${quoteLiteral(settings.memoryLimit)}`);
+        }
+        if (settings.threads != null) {
+            await this.run(`SET threads = ${Math.trunc(settings.threads)}`);
+        }
+    }
+    async run(sql) {
+        await this.connection.run(sql);
+    }
+    async scalar(sql) {
+        const rows = await (await this.connection.run(sql)).getRowsJson();
+        return rows.length === 0 ? undefined : rows[0][0];
+    }
+    async rows(sql) {
+        return (await (await this.connection.run(sql)).getRowsJson());
+    }
+    /**
+     * The columns a query produces, with their DuckDB type objects. No rows are read.
+     *
+     * Type objects rather than `DESCRIBE`'s text, because that text does not quote struct member
+     * names: in `STRUCT(HUGEINT BIGINT)` the member is named `HUGEINT`, and string matching
+     * cannot tell a name from a type.
+    */
+    async columnTypes(sql) {
+        const result = await this.connection.run(`SELECT * FROM (${sql}) LIMIT 0`);
+        const types = result.columnTypes();
+        return result.columnNames().map((name, i) => ({ name, type: types[i] }));
+    }
+    /**
+     * Streams a single-column result as strings, chunk by chunk.
+     *
+     * For output DuckDB has already rendered, such as ldjson lines, where the only work left in
+     * JS is moving bytes. It skips `toPlainValue` because each value is already the final text.
+     * Like `streamRowObjects`, it uses its own connection.
+    */
+    async *streamColumnStrings(sql) {
+        const connection = await this.instance.connect();
+        try {
+            const result = await connection.stream(sql);
+            for (;;) {
+                const chunk = await result.fetchChunk();
+                if (chunk == null || chunk.rowCount === 0)
+                    return;
+                const values = chunk.getColumnValues(0);
+                for (let row = 0; row < chunk.rowCount; row++) {
+                    yield String(values[row]);
+                }
+            }
+        }
+        finally {
+            connection.disconnectSync();
+        }
+    }
+    /**
+     * Streams a query's rows as objects, one DuckDB chunk at a time, so a large result is never
+     * held in JS all at once.
+     *
+     * **Each stream opens its own connection and closes it when the stream ends.** Running any
+     * other query on a connection that holds an open streaming result silently truncates that
+     * stream, with no error. On a shared connection, any frame's `size()` could cut a stream
+     * short.
+     *
+     * `shapers` finish a column's value where the value alone is not enough; for example, a
+     * `Tuple` is stored as a STRUCT but must come out as an array. See `row-shape.ts`.
+    */
+    async *streamRowObjects(sql, shapers = new Map()) {
+        const connection = await this.instance.connect();
+        try {
+            const result = await connection.stream(sql);
+            const names = result.columnNames();
+            for (;;) {
+                const chunk = await result.fetchChunk();
+                // At the end of the result `fetchChunk` returns an empty chunk, repeatedly,
+                // rather than null. An empty chunk is the end; waiting for null would loop
+                // forever. The null check is only a guard.
+                if (chunk == null || chunk.rowCount === 0)
+                    return;
+                const columns = names.map((_name, i) => chunk.getColumnValues(i));
+                const shape = names.map((name) => shapers.get(name));
+                for (let row = 0; row < chunk.rowCount; row++) {
+                    yield Object.fromEntries(names.map((name, col) => {
+                        const value = toPlainValue(columns[col][row]);
+                        return [name, shape[col] ? shape[col](value) : value];
+                    }));
+                }
+            }
+        }
+        finally {
+            // also runs on an early `break` out of a `for await`, not only on exhaustion
+            connection.disconnectSync();
+        }
+    }
+    /**
+     * Closes the connection and the instance.
+     *
+     * Closing the instance is required once a scalar UDF has been registered: a process that
+     * registered one does not exit after `disconnectSync()` alone, and
+     * `DuckDBScalarFunction.destroySync()` does not help. `instance.closeSync()` releases it.
+    */
+    disconnect() {
+        this.connection.disconnectSync();
+        this.instance.closeSync();
+    }
+}
+function resolveExtensionSettings(settings) {
+    const env = extensionSettingsFromEnv();
+    return {
+        extensionDirectory: settings.extensionDirectory ?? env.extensionDirectory,
+        autoinstallExtensions: settings.autoinstallExtensions ?? env.autoinstallExtensions,
+    };
+}
+/** Set at open, not by a later `SET`, so nothing can load from the wrong place first. */
+function instanceOptions(extensions) {
+    return {
+        ...(extensions.extensionDirectory != null && {
+            extension_directory: extensions.extensionDirectory,
+        }),
+        ...(extensions.autoinstallExtensions != null && {
+            autoinstall_known_extensions: String(extensions.autoinstallExtensions),
+        }),
+    };
+}
+function sameDirectory(a, b) {
+    return b != null && resolve(a) === resolve(b);
+}
+//# sourceMappingURL=DuckContext.js.map

package/dist/src/teal-frame/DuckContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DuckContext.js","sourceRoot":"","sources":["../../../src/teal-frame/DuckContext.ts"],"names":[],"mappings":"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"}

package/dist/src/teal-frame/TealFrame.d.ts

@@ -0,0 +1,371 @@
+import { SQLSearchParams } from '@terascope/types';
+import { type SQLSortInput } from '@terascope/sql-builder';
+import { JsonExportOptions } from './export-json.js';
+import { ExpandValuesOptions } from './expand-values.js';
+import { AppendOptions, AppendSource, FrameConfig, FrameOptions, FromRecordsOptions, JoinOptions, SelectList, SelectOptions } from './interfaces.js';
+/**
+ * A frame whose rows live in DuckDB.
+ *
+ * TealFrame has its own API; it does not wrap or replace `DataFrame`. Its methods fall into
+ * three groups:
+ *
+ * 1. **Compose a statement:** `filter`, `select`, `orderBy`, `limit`, `distinct`, `join`,
+ *    `deepSelect`, `pruneEmptyObjects`, `expandValues` and `removeEmptyRows`. Each returns a
+ *    new frame over one more SQL step. Nothing runs yet.
+ * 2. **Run an existing statement:** `query` (instance) and `fromSQL` (static).
+ * 3. **Consume:** `rows`, `size`, `ndjson`, `writeNDJSON`, `writeParquet`, `listValues` and
+ *    `countEmptyRows`. These execute the statement and produce output.
+ *
+ * `filter` and `select` are clause builders, not a search API: `filter` is the `WHERE` clause
+ * and `select` is the `SELECT` list, just as `orderBy` is the `ORDER BY`. They exist for
+ * callers that build a query one step at a time. For example, `tealFrameAdapter` returns an
+ * expression for one function on one column, and a chain of transforms becomes a chain of
+ * `select` calls that compose into one statement evaluated in a single pass.
+ *
+ * If you already have a complete statement, such as one from `QueryAccess`, pass it to
+ * `query` whole. Rebuilding a restricted statement from `filter` and `select` can drop a
+ * field restriction.
+*/
+export declare class TealFrame {
+    private readonly ctx;
+    readonly config: FrameConfig;
+    /**
+     * Not readonly: `append` may promote a relation to a table, because a frame manages
+     * its own storage. Every other operation returns a new frame and leaves this one
+     * unchanged.
+    */
+    private source;
+    readonly columns: readonly string[];
+    private constructor();
+    /** The in-flight promotion of a relation to a table, shared by concurrent appends. */
+    private promotion?;
+    /** True when the rows are in a real table rather than recomputed per reference. */
+    get isMaterialized(): boolean;
+    /**
+     * True when this frame's rows come out in a defined order.
+     *
+     * Set by `orderBy` and kept by the operators that preserve order. Operations that would
+     * discard the order check it and throw.
+    */
+    get isOrdered(): boolean;
+    /** Refuses an operation that would silently discard an ordering - see `order-safety.ts`. */
+    private assertOrderSafe;
+    /** A new relation-backed frame over `sql` on the same database. */
+    private derive;
+    /**
+     * SQL naming this frame's rows, usable directly in a `FROM` clause.
+     *
+     * For a materialized frame this is its quoted table name; for a relation it is a
+     * parenthesized subquery, so composed frames reach DuckDB's optimizer as a single
+     * statement.
+    */
+    get from(): string;
+    /**
+     * Returns a frame over the rows of a complete SQL statement.
+     *
+     * Use it to run a statement from `QueryAccess.restrictSQLQuery`, which is a finished
+     * `SELECT` that already carries the field restrictions:
+     *
+     * ```ts
+     * const sql = await access.restrictSQLQuery(query, { params: frame.searchParams(size) });
+     * for await (const row of frame.query(sql).rows()) { ... }
+     * ```
+     *
+     * The statement runs only when rows are requested, and it composes with other operations:
+     * `frame.query(sql).limit(10)` is one statement.
+     *
+     * `config` defaults to this frame's config. Pass the right config when the statement's
+     * `SELECT` list produces different fields. If the statement references its source more
+     * than once, materialize this frame first; see `searchParams`.
+     *
+     * @param sql A complete SQL statement.
+     * @param config The field types the statement produces. Defaults to this frame's config.
+     * @param columns The output column names. Defaults to the top-level fields of `config`.
+    */
+    query(sql: string, config?: FrameConfig, columns?: readonly string[]): TealFrame;
+    /**
+     * Runs SQL and returns positional rows, with values as DuckDB renders them to JSON. This is
+     * for inspection, not for reading data; use `query(sql).rows()` to read data.
+     *
+     * Unlike `query`, it needs no `DataTypeConfig`, so it can run catalog queries such as
+     * `DESCRIBE`. It also skips the conversion to output values, so it shows what DuckDB
+     * actually stores.
+     *
+     * @internal
+    */
+    rawRows(sql: string): Promise<unknown[][]>;
+    /**
+     * The `SQLSearchParams` that name this frame as the source of a `QueryAccess` statement.
+     *
+     * A materialized frame reports `table`, which is quoted as an identifier. A relation-backed
+     * frame reports `relation`, its SQL used verbatim.
+     *
+     * Prefer a table when the generated statement may reference its source more than once
+     * (a self-join, a correlated subquery, a `UNION`). Each reference to a relation re-runs the
+     * whole subquery, while a table is read directly. Call `materialize()` first in that case.
+     *
+     * @param size The page size, rendered as `LIMIT`.
+     * @param from The page start, rendered as `OFFSET`.
+    */
+    searchParams(size?: number, from?: number): SQLSearchParams;
+    /** The backing table name, when this frame is materialized. */
+    get table(): string | undefined;
+    /**
+     * Creates an empty frame backed by a new table. This is the usual way to make a frame;
+     * add rows with `append`.
+    */
+    static create(config: FrameConfig, options?: FrameOptions): Promise<TealFrame>;
+    /**
+     * Adds rows to this frame, from parsed records or from Parquet files, and returns the
+     * number of rows added.
+     *
+     * Records are coerced to the frame's field types; Parquet is already typed and is not.
+     *
+     * If the frame is a relation, it is first promoted to a table in place. Frames already
+     * derived from it keep the SQL they captured and are unaffected.
+     *
+     * The append runs in a transaction, so a failed batch leaves the table exactly as it was.
+     * When a table is assembled from many batches, a bad one cannot corrupt those already in it.
+     *
+     * **Finish appending before deriving other frames from this one.** Derived frames read the
+     * table by name, so a later append changes their results too.
+    */
+    append(source: AppendSource, options?: AppendOptions): Promise<number>;
+    /**
+     * Promotes a relation to a table in place, so this frame has storage to append to.
+     *
+     * The promotion is shared, so two concurrent appends do not each create a table and split
+     * the rows between them.
+    */
+    private ensureTable;
+    private promoteToTable;
+    /**
+     * Creates a frame from parsed JS records, such as Elasticsearch documents.
+     *
+     * Each value is coerced to its field type. In `strict` mode (the default) the first value
+     * that does not fit throws a `CoercionFailureError`, as `DataFrame`'s builder does. In
+     * `lenient` mode the value is stored as null and each failing field is recorded with a count
+     * and an example value.
+     *
+     * If the records cannot be added, the new table is dropped before the error is thrown.
+    */
+    static fromRecords(config: FrameConfig, records: readonly Record<string, unknown>[], options?: FromRecordsOptions): Promise<TealFrame>;
+    /**
+     * Creates a frame over Parquet files, without coercing their values.
+     *
+     * Parquet carries its own schema, so column types are already enforced; the values are
+     * expected to have been validated when the files were written.
+     *
+     * @param path One path, a list of paths, or a glob. Several files read as one relation.
+    */
+    static fromParquet(config: FrameConfig, path: string | readonly string[], options?: FrameOptions): Promise<TealFrame>;
+    /**
+     * Creates a frame over a complete SQL statement whose source is named in the SQL itself,
+     * such as `read_parquet([...])` or an existing table.
+     *
+     * Use the instance method `query()` instead when the statement was built against an
+     * existing frame.
+     *
+     * ```ts
+     * const sql = await access.restrictSQLQuery(query, {
+     *     params: { relation: `read_parquet(${...})`, size: 100 }
+     * });
+     * const frame = await TealFrame.fromSQL(sql, config);
+     * ```
+     *
+     * Nothing runs until rows are requested. The statement is not validated, so any error
+     * comes from DuckDB when it executes.
+    */
+    static fromSQL(sql: string, config: FrameConfig, options?: FrameOptions): Promise<TealFrame>;
+    /**
+     * Copies this frame's rows into a new table and returns a new frame over it. The original
+     * frame is unchanged. A frame that is already a table is returned as is.
+     *
+     * A relation is recomputed every time it is referenced, so materializing pays off when the
+     * relation is expensive and used more than once. For a single use it is slower, and a
+     * cheap relation over a table never needs it.
+    */
+    materialize(name?: string): Promise<TealFrame>;
+    /**
+     * Sets the `SELECT` list, returning a new frame.
+     *
+     * Every column-level operation is a projection: applying a transform or validation,
+     * renaming, dropping, or adding a derived column. Chained `select` calls compose into one
+     * statement evaluated in a single pass, where `DataFrame` makes a pass per function.
+     * Expressions may be native SQL or calls to registered UDFs.
+     *
+     * To run a complete statement, use `query` instead.
+     *
+     * @param expressions A map of `{ outputName: sqlExpression }`, or a verbatim `SELECT` list.
+     * @param options The result's config and column names, and an optional `groupBy`. Grouping
+     * an ordered frame throws, because it would discard the order.
+    */
+    select(expressions: SelectList, options?: SelectOptions): TealFrame;
+    /**
+     * Joins another frame, returning a new frame.
+     *
+     * Either side may be a table or a relation. Both sides are aliased (`a` and `b` by
+     * default), because two frames often share column names; write `on` and `select` in terms
+     * of those aliases. `groupBy` lets a join and an aggregation run as one statement.
+     *
+     * Both frames must be in the same database, and neither may be ordered, because a join
+     * does not keep row order.
+    */
+    join(other: TealFrame, options: JoinOptions): TealFrame;
+    /**
+     * Adds a `WHERE` clause, returning a new frame.
+     *
+     * The predicate is raw SQL, so the caller must quote identifiers itself: a field named
+     * `group` needs `filter('"group" = \'y\'')`. To run a complete statement, such as one
+     * from `QueryAccess`, use `query` instead.
+     *
+     * A filter keeps row order, so a sorted frame stays sorted.
+    */
+    filter(predicate: string): TealFrame;
+    /**
+     * Removes duplicate rows, comparing every column (`SELECT DISTINCT *`). Returns a new
+     * frame.
+     *
+     * It works on list and object columns, and treats nulls as equal, so rows that are null in
+     * the same column collapse into one.
+     *
+     * `DISTINCT` does not keep row order, so it throws on an ordered frame and its result is
+     * unordered. Remove duplicates first, then sort.
+    */
+    distinct(): TealFrame;
+    /**
+     * Adds an `ORDER BY`, returning a new frame.
+     *
+     * The sort wraps the current relation in a subquery. DuckDB's optimizer flattens the
+     * nesting, so `.orderBy(x).limit(10)` runs as a single top-N query. The order of calls
+     * means what it says:
+     *
+     * | chain | means |
+     * |---|---|
+     * | `.orderBy(x).limit(10)` | the top 10 by x |
+     * | `.limit(10).orderBy(x)` | an arbitrary 10, sorted |
+     * | `.orderBy(x).filter(p).limit(10)` | the top 10 of the matching rows |
+     * | `.orderBy(x).limit(10).filter(p)` | the top 10, then filtered - may yield fewer |
+     *
+     * `select`, `filter` and `limit` may follow a sort. `join`, `distinct` and a grouping
+     * `select` throw on a sorted frame, because they would discard the order. `materialize()`
+     * drops the order, because a table has none.
+     *
+     * Nulls sort as in `DataFrame`: first when ascending, last when descending.
+     *
+     * **Ties are not ordered deterministically.** DuckDB sorts in parallel and is not stable,
+     * so rows with equal sort values can come back in a different order on each run, and
+     * paging over them can repeat or skip rows. `DataFrame` sorts with the stable
+     * `Array#sort`. A caller that pages must end `sort` with a unique field.
+     *
+     * @param sort The sort terms, at least one.
+    */
+    orderBy(sort: readonly SQLSortInput[]): TealFrame;
+    /**
+     * Adds `LIMIT` and `OFFSET`, returning a new frame.
+     *
+     * Either bound may be given alone; with neither, the frame is returned unchanged, so
+     * optional paging values can be passed straight through.
+     *
+     * Prefer `limit` to stopping early in `rows()`. DuckDB stops reading once an unsorted
+     * limit is satisfied, and for a sorted one keeps only the top `count` rows instead of
+     * sorting everything. Breaking out of `rows()` stops only the JS consumer.
+     *
+     * A limit keeps row order. Note that `size()` on a limited frame counts the page, not the
+     * total; call `size()` on the frame before the limit to get the total.
+     *
+     * @param count The maximum number of rows (`LIMIT`).
+     * @param offset The number of rows to skip (`OFFSET`).
+    */
+    limit(count?: number, offset?: number): TealFrame;
+    /** Counts the frame's rows. */
+    size(): Promise<number>;
+    /**
+     * Writes the frame to a Parquet file compressed with zstd, for moving data between
+     * processes.
+     *
+     * Parquet's built-in zstd compression is much faster than gzipping JSON output and
+     * produces a smaller file.
+    */
+    writeParquet(path: string): Promise<void>;
+    /**
+     * Writes the frame to a file as ldjson, one JSON object per line.
+     *
+     * DuckDB writes the file, so rows never become JS objects and this is much faster than
+     * serializing `rows()`.
+     *
+     * The output is byte-identical to `DataFrame.toJSON` with the same `SerializeOptions`,
+     * including ISO 8601 dates and integers past `MAX_SAFE_INTEGER` written as strings. See
+     * `export-json.ts`.
+     *
+     * With no options, null fields and empty objects are omitted (`removeNullFields: true`).
+     * Any explicit `SerializeOptions` flag means exactly what it means to `DataFrame`.
+     *
+     * The promise resolves once the whole file is written. Use `ndjson()` to stream the lines
+     * instead, for example to upload them as they are produced.
+    */
+    writeNDJSON(path: string, options?: JsonExportOptions): Promise<void>;
+    /**
+     * Streams the frame as ldjson lines, byte-identical to what `writeNDJSON` writes.
+     *
+     * DuckDB renders each line, so JavaScript only passes strings along. A caller can upload
+     * the lines as they arrive and never hold the whole result in memory.
+    */
+    ndjson(options?: JsonExportOptions): AsyncIterableIterator<string>;
+    /**
+     * Streams the frame's rows as JS objects.
+     *
+     * With `options`, it yields what `DataFrame.rows(true, options)` yields, by parsing the
+     * lines `ndjson(options)` produces. Without options, it yields every column, with a nil
+     * value as `null`.
+     *
+     * There is no `toArray()` or `getColumn()`: the data lives in DuckDB, so column-level work
+     * belongs in SQL, and a result may be too large to hold as an array.
+    */
+    rows(options?: JsonExportOptions): AsyncIterableIterator<Record<string, unknown>>;
+    /**
+     * Streams the elements of a list column in the first row, as
+     * `ListVector.getRowIterator(0, true, options)` yields them.
+     *
+     * Useful for a one-row frame whose single list column holds the real result. Each element
+     * is rendered by the same rules as `ndjson(options)`. A nil element is yielded as `null`
+     * under `useNullForUndefined`, as `undefined` otherwise, and skipped under
+     * `skipNilListValues` (or `skipNilObjectValues` for object elements). As in `DataFrame`,
+     * nothing is yielded under `skipEmptyArrays` when the column is empty, and
+     * `skipDuplicateObjects` is not supported.
+    */
+    listValues(column: string, options?: JsonExportOptions): AsyncIterableIterator<unknown>;
+    /**
+     * Keeps only the selected fields, as `DataFrame.deepSelect` does. Dotted paths select
+     * fields inside nested objects, and names that do not exist are ignored. See
+     * `deep-select.ts`.
+    */
+    deepSelect(fields: readonly string[]): TealFrame;
+    /**
+     * Drops every Object column marked `_skip_if_empty` that has no declared child fields left,
+     * typically after `deepSelect`. Decided from the config alone; no rows are read.
+    */
+    pruneEmptyObjects(): TealFrame;
+    /**
+     * Expands array fields into one row per element, as the `@expandValues` directive does.
+     * See `expand-values.ts` for the two modes. Row order is kept, and so is a row with nothing
+     * to expand. The expanded fields become `array: false`.
+    */
+    expandValues(fields: readonly string[], options: ExpandValuesOptions): TealFrame;
+    /**
+     * Counts the rows where every column is null, as `DataFrame.countEmptyRows` does. A row
+     * holding `{}` or `[]` is not empty, because the stored value is tested, not its JSON form.
+    */
+    countEmptyRows(): Promise<number>;
+    /** Keeps the rows that are not empty, in order, as `DataFrame.removeEmptyRows` does. */
+    removeEmptyRows(): TealFrame;
+    private emptyRow;
+    /**
+     * Drops the backing table, if this frame has one. A relation has nothing to drop.
+     *
+     * Call it only once no frame derived from this one is still in use, because derived
+     * frames read the table by name.
+    */
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=TealFrame.d.ts.map

package/dist/src/teal-frame/TealFrame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TealFrame.d.ts","sourceRoot":"","sources":["../../../src/teal-frame/TealFrame.ts"],"names":[],"mappings":"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"}