@haybarn/node-api 1.5.5-rc1 → 2.0.0-rc3

package/lib/DuckDBDataChunk.js

@@ -13,7 +13,16 @@ class DuckDBDataChunk {
         this.chunk = chunk;
     }
     static create(types, rowCount) {
-        const chunk = new DuckDBDataChunk(node_bindings_1.default.create_data_chunk(types.map((t) => t.toLogicalType().logical_type)));
+        let chunk;
+        try {
+            chunk = new DuckDBDataChunk(node_bindings_1.default.create_data_chunk(types.map((t) => t.toLogicalType().logical_type)));
+        }
+        catch (cause) {
+            // The binding knows the chunk was refused but not which type did it, so
+            // name them here. Zero columns is a legitimate chunk, so there is
+            // nothing to check on the way out; only the refusal is an error.
+            throw new Error(`Cannot create a data chunk with these column types: ${types.join(', ')}`, { cause });
+        }
         if (rowCount != undefined) {
             chunk.rowCount = rowCount;
         }
@@ -34,6 +43,23 @@ class DuckDBDataChunk {
             throw new Error(`A data chunk cannot have more than ${maxRowCount} rows`);
         }
         node_bindings_1.default.data_chunk_set_size(this.chunk, count);
+        // Cached vectors were built for the previous row count, so they are the
+        // wrong size now. This matters most for a table function's output chunk,
+        // which arrives empty and is sized by the function on every call.
+        this.vectors.length = 0;
+    }
+    /**
+     * Refuses a column count that does not match the chunk's.
+     *
+     * A short array would leave the remaining vectors never written and never
+     * flushed while the chunk reports a non-zero row count, and reading or
+     * appending it then crashes the process instead of raising.
+     */
+    assertColumnCount(count) {
+        const columnCount = this.columnCount;
+        if (count !== columnCount) {
+            throw new Error(`Provided number of columns (${count}) does not match chunk column count (${columnCount})`);
+        }
     }
     getColumnVector(columnIndex) {
         if (this.vectors[columnIndex]) {
@@ -73,6 +99,31 @@ class DuckDBDataChunk {
         }
         vector.flush();
     }
+    /**
+     * `setColumnValues` with each value converted on the way in: the write
+     * counterpart of `convertColumnValues`.
+     *
+     * The column's type comes from its vector, so the converter is the only
+     * thing the caller supplies.
+     */
+    setColumnValuesConverted(columnIndex, values, converter) {
+        const vector = this.getColumnVector(columnIndex);
+        if (vector.itemCount !== values.length) {
+            throw new Error(`number of values must equal chunk row count`);
+        }
+        const { type } = vector;
+        try {
+            for (let i = 0; i < values.length; i++) {
+                vector.setItem(i, converter(values[i], type, converter));
+            }
+        }
+        catch (cause) {
+            throw new Error(`Failed to set column ${columnIndex} (${type})`, {
+                cause,
+            });
+        }
+        vector.flush();
+    }
     visitColumns(visitColumn) {
         const columnCount = this.columnCount;
         for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
@@ -104,6 +155,7 @@ class DuckDBDataChunk {
         return convertedColumns;
     }
     setColumns(columns) {
+        this.assertColumnCount(columns.length);
         if (columns.length > 0) {
             this.rowCount = columns[0].length;
         }
@@ -111,6 +163,19 @@ class DuckDBDataChunk {
             this.setColumnValues(columnIndex, columns[columnIndex]);
         }
     }
+    /**
+     * `setColumns` with each value converted on the way in: the write
+     * counterpart of `convertColumns`.
+     */
+    setColumnsConverted(columns, converter) {
+        this.assertColumnCount(columns.length);
+        if (columns.length > 0) {
+            this.rowCount = columns[0].length;
+        }
+        for (let columnIndex = 0; columnIndex < columns.length; columnIndex++) {
+            this.setColumnValuesConverted(columnIndex, columns[columnIndex], converter);
+        }
+    }
     appendToColumnsObject(columnNames, columnsObject) {
         const columnCount = this.columnCount;
         if (columnNames.length !== columnCount) {
@@ -190,6 +255,34 @@ class DuckDBDataChunk {
             vector.flush();
         }
     }
+    /**
+     * `setRows` with each value converted on the way in: the write counterpart
+     * of `convertRows`.
+     *
+     * Each column's type comes from its vector, so the converter is the only
+     * thing the caller supplies.
+     */
+    setRowsConverted(rows, converter) {
+        this.rowCount = rows.length;
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            const vector = this.getColumnVector(columnIndex);
+            const { type } = vector;
+            // Wrapped per column rather than per value: a conversion failure names
+            // the column it came from without a try/catch in the inner loop.
+            try {
+                for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+                    vector.setItem(rowIndex, converter(rows[rowIndex][columnIndex], type, converter));
+                }
+            }
+            catch (cause) {
+                throw new Error(`Failed to set column ${columnIndex} (${type})`, {
+                    cause,
+                });
+            }
+            vector.flush();
+        }
+    }
     appendToRowObjects(columnNames, rowObjects) {
         const columnCount = this.columnCount;
         if (columnNames.length !== columnCount) {

package/lib/DuckDBDataChunkWriter.d.ts

@@ -0,0 +1,74 @@
+import type { DuckDBAppender } from './DuckDBAppender';
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBType } from './DuckDBType';
+import { ToDuckDBValueConverter } from './ToDuckDBValueConverter';
+import { DuckDBValue } from './values';
+/** Receives each data chunk a `DuckDBDataChunkWriter` fills. */
+export type DuckDBDataChunkSink = (chunk: DuckDBDataChunk) => void;
+/**
+ * `converter` is optional only when the rows are already `DuckDBValue`s, which
+ * is what `T` defaults to. Supply one to write some other representation —
+ * `JSToDuckDBValueConverter` for plain JS — and `T` follows from it.
+ */
+export type DuckDBDataChunkWriterOptions<T> = {
+    /**
+     * How many rows each emitted data chunk holds — its `rowCount`. Defaults to
+     * the DuckDB vector size, which is also the most a data chunk can hold.
+     */
+    readonly rowsPerDataChunk?: number;
+} & ([DuckDBValue] extends [T] ? {
+    readonly converter?: ToDuckDBValueConverter<T>;
+} : {
+    readonly converter: ToDuckDBValueConverter<T>;
+});
+/**
+ * Accumulates rows and emits them as filled data chunks, one per
+ * `rowsPerDataChunk` rows, passing each to `sink`.
+ *
+ * Rows are `DuckDBValue`s by default. Supply a converter to write some other
+ * representation; the row type follows from it.
+ *
+ *     const writer = DuckDBDataChunkWriter.forAppender(appender, {
+ *       converter: JSToDuckDBValueConverter,
+ *     });
+ *     for (const row of rows) {
+ *       writer.appendRow(row);
+ *     }
+ *     writer.flush();
+ *
+ * `flush` emits whatever is buffered, so call it when done: the last chunk is
+ * usually a partial one. Rows already grouped into chunk-sized batches need no
+ * writer — fill a `DuckDBDataChunk` and pass it to the destination directly.
+ */
+export declare class DuckDBDataChunkWriter<T = DuckDBValue> {
+    private readonly types;
+    private readonly sink;
+    private readonly rowsPerDataChunk;
+    private readonly converter?;
+    private rows;
+    constructor(types: readonly DuckDBType[], sink: DuckDBDataChunkSink, options?: DuckDBDataChunkWriterOptions<T>);
+    /**
+     * A writer that appends each filled data chunk to `appender`, using the
+     * appender's own column types.
+     *
+     * Equivalent to constructing one with those types and a sink that calls
+     * `appendDataChunk`, but with nothing to keep in step by hand.
+     */
+    static forAppender<T = DuckDBValue>(appender: DuckDBAppender, options?: DuckDBDataChunkWriterOptions<T>): DuckDBDataChunkWriter<T>;
+    get bufferedRowCount(): number;
+    /**
+     * Buffers one row, emitting a data chunk once `rowsPerDataChunk` are held.
+     *
+     * The row is copied, so the same array can be reused across calls.
+     */
+    appendRow(values: readonly (T | null)[]): void;
+    /**
+     * Emits the buffered rows as one data chunk. A no-op when none are
+     * buffered, so it is safe to call more than once.
+     *
+     * The buffer is emptied either way: if converting the rows fails, or the
+     * sink rejects the chunk, those rows are discarded along with the error.
+     * Appending afterwards starts a fresh chunk.
+     */
+    flush(): void;
+}

package/lib/DuckDBDataChunkWriter.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBDataChunkWriter = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBDataChunk_1 = require("./DuckDBDataChunk");
+/**
+ * Accumulates rows and emits them as filled data chunks, one per
+ * `rowsPerDataChunk` rows, passing each to `sink`.
+ *
+ * Rows are `DuckDBValue`s by default. Supply a converter to write some other
+ * representation; the row type follows from it.
+ *
+ *     const writer = DuckDBDataChunkWriter.forAppender(appender, {
+ *       converter: JSToDuckDBValueConverter,
+ *     });
+ *     for (const row of rows) {
+ *       writer.appendRow(row);
+ *     }
+ *     writer.flush();
+ *
+ * `flush` emits whatever is buffered, so call it when done: the last chunk is
+ * usually a partial one. Rows already grouped into chunk-sized batches need no
+ * writer — fill a `DuckDBDataChunk` and pass it to the destination directly.
+ */
+class DuckDBDataChunkWriter {
+    types;
+    sink;
+    rowsPerDataChunk;
+    converter;
+    rows = [];
+    constructor(types, sink, options = {}) {
+        this.types = types;
+        this.sink = sink;
+        const maxRowCount = node_bindings_1.default.vector_size();
+        this.rowsPerDataChunk = options.rowsPerDataChunk ?? maxRowCount;
+        // Checked here rather than left to the first flush, which is where the
+        // chunk itself would refuse it — a whole buffer's worth of rows later.
+        if (this.rowsPerDataChunk < 1 || this.rowsPerDataChunk > maxRowCount) {
+            throw new Error(`rowsPerDataChunk must be between 1 and ${maxRowCount}, got ${this.rowsPerDataChunk}`);
+        }
+        this.converter = options.converter;
+    }
+    /**
+     * A writer that appends each filled data chunk to `appender`, using the
+     * appender's own column types.
+     *
+     * Equivalent to constructing one with those types and a sink that calls
+     * `appendDataChunk`, but with nothing to keep in step by hand.
+     */
+    static forAppender(appender, options = {}) {
+        const types = [];
+        const columnCount = appender.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            types.push(appender.columnType(columnIndex));
+        }
+        return new DuckDBDataChunkWriter(types, (chunk) => appender.appendDataChunk(chunk), options);
+    }
+    get bufferedRowCount() {
+        return this.rows.length;
+    }
+    /**
+     * Buffers one row, emitting a data chunk once `rowsPerDataChunk` are held.
+     *
+     * The row is copied, so the same array can be reused across calls.
+     */
+    appendRow(values) {
+        if (values.length !== this.types.length) {
+            throw new Error(`Provided number of values (${values.length}) does not match number of types (${this.types.length})`);
+        }
+        this.rows.push(values.slice());
+        if (this.rows.length >= this.rowsPerDataChunk) {
+            this.flush();
+        }
+    }
+    /**
+     * Emits the buffered rows as one data chunk. A no-op when none are
+     * buffered, so it is safe to call more than once.
+     *
+     * The buffer is emptied either way: if converting the rows fails, or the
+     * sink rejects the chunk, those rows are discarded along with the error.
+     * Appending afterwards starts a fresh chunk.
+     */
+    flush() {
+        if (this.rows.length === 0) {
+            return;
+        }
+        // Taken before anything that can throw. Left in place, a batch that failed
+        // to convert or that the sink rejected would still be buffered, and later
+        // appends would grow it past `rowsPerDataChunk` and eventually past what a
+        // data chunk can hold at all — by which point the writer can no longer
+        // flush and the original error is long gone.
+        const rows = this.rows;
+        this.rows = [];
+        const chunk = DuckDBDataChunk_1.DuckDBDataChunk.create(this.types);
+        if (this.converter) {
+            chunk.setRowsConverted(rows, this.converter);
+        }
+        else {
+            // Without a converter the options type has already constrained `T` to
+            // `DuckDBValue`, which is the only thing that makes this cast sound.
+            chunk.setRows(rows);
+        }
+        this.sink(chunk);
+    }
+}
+exports.DuckDBDataChunkWriter = DuckDBDataChunkWriter;

package/lib/DuckDBLogicalType.d.ts

@@ -1,5 +1,5 @@
 import duckdb from '@haybarn/node-bindings';
-import { DuckDBArrayType, DuckDBDecimalType, DuckDBEnumType, DuckDBListType, DuckDBMapType, DuckDBStructType, DuckDBType, DuckDBUnionType } from './DuckDBType';
+import { DuckDBArrayType, DuckDBDecimalType, DuckDBEnumType, DuckDBGeometryType, DuckDBListType, DuckDBMapType, DuckDBStructType, DuckDBType, DuckDBUnionType } from './DuckDBType';
 import { DuckDBTypeId } from './DuckDBTypeId';
 export declare class DuckDBLogicalType {
     readonly logical_type: duckdb.LogicalType;
@@ -64,3 +64,7 @@ export declare class DuckDBUnionLogicalType extends DuckDBLogicalType {
     memberTypes(): DuckDBType[];
     asType(): DuckDBUnionType;
 }
+export declare class DuckDBGeometryLogicalType extends DuckDBLogicalType {
+    get crs(): string | undefined;
+    asType(): DuckDBGeometryType;
+}

package/lib/DuckDBLogicalType.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DuckDBUnionLogicalType = exports.DuckDBArrayLogicalType = exports.DuckDBMapLogicalType = exports.DuckDBStructLogicalType = exports.DuckDBListLogicalType = exports.DuckDBEnumLogicalType = exports.DuckDBDecimalLogicalType = exports.DuckDBLogicalType = void 0;
+exports.DuckDBGeometryLogicalType = exports.DuckDBUnionLogicalType = exports.DuckDBArrayLogicalType = exports.DuckDBMapLogicalType = exports.DuckDBStructLogicalType = exports.DuckDBListLogicalType = exports.DuckDBEnumLogicalType = exports.DuckDBDecimalLogicalType = exports.DuckDBLogicalType = void 0;
 const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
 const DuckDBType_1 = require("./DuckDBType");
 const DuckDBTypeId_1 = require("./DuckDBTypeId");
@@ -28,6 +28,8 @@ class DuckDBLogicalType {
                 return new DuckDBArrayLogicalType(logical_type);
             case node_bindings_1.default.Type.UNION:
                 return new DuckDBUnionLogicalType(logical_type);
+            case node_bindings_1.default.Type.GEOMETRY:
+                return new DuckDBGeometryLogicalType(logical_type);
             default:
                 return new DuckDBLogicalType(logical_type);
         }
@@ -165,6 +167,12 @@ class DuckDBLogicalType {
                 return DuckDBType_1.DuckDBIntegerLiteralType.create(alias);
             case DuckDBTypeId_1.DuckDBTypeId.TIME_NS:
                 return DuckDBType_1.DuckDBTimeNSType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.GEOMETRY:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.VARIANT:
+                return DuckDBType_1.DuckDBVariantType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_TZ_NS:
+                return DuckDBType_1.DuckDBTimestampTZNanosecondsType.create(alias);
             default:
                 throw new Error(`Unexpected type id: ${this.typeId}`);
         }
@@ -326,3 +334,12 @@ class DuckDBUnionLogicalType extends DuckDBLogicalType {
     }
 }
 exports.DuckDBUnionLogicalType = DuckDBUnionLogicalType;
+class DuckDBGeometryLogicalType extends DuckDBLogicalType {
+    get crs() {
+        return node_bindings_1.default.geometry_type_get_crs(this.logical_type) || undefined;
+    }
+    asType() {
+        return DuckDBType_1.DuckDBGeometryType.create(this.alias, this.crs);
+    }
+}
+exports.DuckDBGeometryLogicalType = DuckDBGeometryLogicalType;

package/lib/DuckDBMaterializedResult.d.ts

@@ -1,8 +1,15 @@
 import duckdb from '@haybarn/node-bindings';
 import { DuckDBDataChunk } from './DuckDBDataChunk';
 import { DuckDBResult } from './DuckDBResult';
+import { StatementType } from './enums';
 export declare class DuckDBMaterializedResult extends DuckDBResult {
-    constructor(result: duckdb.Result);
+    private closedCounts;
+    constructor(result: duckdb.Result, preparedStatementType?: StatementType);
+    /**
+     * Same as `DuckDBResult.closeSync`; the row and chunk counts also stay
+     * available. Getting a chunk throws.
+     */
+    closeSync(): void;
     get rowCount(): number;
     get chunkCount(): number;
     getChunk(chunkIndex: number): DuckDBDataChunk;

package/lib/DuckDBMaterializedResult.js

@@ -8,13 +8,33 @@ const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
 const DuckDBDataChunk_1 = require("./DuckDBDataChunk");
 const DuckDBResult_1 = require("./DuckDBResult");
 class DuckDBMaterializedResult extends DuckDBResult_1.DuckDBResult {
-    constructor(result) {
-        super(result);
+    closedCounts;
+    constructor(result, preparedStatementType) {
+        super(result, preparedStatementType);
+    }
+    /**
+     * Same as `DuckDBResult.closeSync`; the row and chunk counts also stay
+     * available. Getting a chunk throws.
+     */
+    closeSync() {
+        if (!this.closedCounts) {
+            this.closedCounts = {
+                rowCount: this.rowCount,
+                chunkCount: this.chunkCount,
+            };
+        }
+        super.closeSync();
     }
     get rowCount() {
+        if (this.closedCounts) {
+            return this.closedCounts.rowCount;
+        }
         return node_bindings_1.default.row_count(this.result);
     }
     get chunkCount() {
+        if (this.closedCounts) {
+            return this.closedCounts.chunkCount;
+        }
         return node_bindings_1.default.result_chunk_count(this.result);
     }
     getChunk(chunkIndex) {

package/lib/DuckDBPendingResult.d.ts

@@ -1,6 +1,7 @@
 import duckdb from '@haybarn/node-bindings';
 import { DuckDBResult } from './DuckDBResult';
 import { DuckDBResultReader } from './DuckDBResultReader';
+import { StatementType } from './enums';
 export declare enum DuckDBPendingResultState {
     RESULT_READY = 0,
     RESULT_NOT_READY = 1,
@@ -8,7 +9,21 @@ export declare enum DuckDBPendingResultState {
 }
 export declare class DuckDBPendingResult {
     private readonly pending_result;
-    constructor(pending_result: duckdb.PendingResult);
+    private readonly preparedStatementType;
+    /**
+     * `preparedStatementType` is passed on to the result; see `DuckDBResult`.
+     */
+    constructor(pending_result: duckdb.PendingResult, preparedStatementType?: StatementType);
+    /**
+     * Destroys the pending result. On DuckDB 2.0, a pending result whose result
+     * has not been gotten blocks its connection from starting another statement
+     * until it is closed.
+     *
+     * Running tasks or getting the result afterwards throws. If getting the
+     * result is in flight, the pending result is destroyed once it finishes; the
+     * result it returns is unaffected. Closing again does nothing.
+     */
+    closeSync(): void;
     runTask(): DuckDBPendingResultState;
     runAllTasks(): Promise<void>;
     getResult(): Promise<DuckDBResult>;

package/lib/DuckDBPendingResult.js

@@ -17,8 +17,25 @@ var DuckDBPendingResultState;
 })(DuckDBPendingResultState || (exports.DuckDBPendingResultState = DuckDBPendingResultState = {}));
 class DuckDBPendingResult {
     pending_result;
-    constructor(pending_result) {
+    preparedStatementType;
+    /**
+     * `preparedStatementType` is passed on to the result; see `DuckDBResult`.
+     */
+    constructor(pending_result, preparedStatementType) {
         this.pending_result = pending_result;
+        this.preparedStatementType = preparedStatementType;
+    }
+    /**
+     * Destroys the pending result. On DuckDB 2.0, a pending result whose result
+     * has not been gotten blocks its connection from starting another statement
+     * until it is closed.
+     *
+     * Running tasks or getting the result afterwards throws. If getting the
+     * result is in flight, the pending result is destroyed once it finishes; the
+     * result it returns is unaffected. Closing again does nothing.
+     */
+    closeSync() {
+        node_bindings_1.default.destroy_pending_sync(this.pending_result);
     }
     runTask() {
         const pending_state = node_bindings_1.default.pending_execute_task(this.pending_result);
@@ -41,7 +58,7 @@ class DuckDBPendingResult {
         }
     }
     async getResult() {
-        return (0, createResult_1.createResult)(await node_bindings_1.default.execute_pending(this.pending_result));
+        return (0, createResult_1.createResult)(await node_bindings_1.default.execute_pending(this.pending_result), this.preparedStatementType);
     }
     async read() {
         return new DuckDBResultReader_1.DuckDBResultReader(await this.getResult());

package/lib/DuckDBPreparedStatement.d.ts

@@ -6,7 +6,7 @@ import { DuckDBResultReader } from './DuckDBResultReader';
 import { DuckDBArrayType, DuckDBEnumType, DuckDBListType, DuckDBMapType, DuckDBStructType, DuckDBType, DuckDBUnionType } from './DuckDBType';
 import { DuckDBTypeId } from './DuckDBTypeId';
 import { StatementType } from './enums';
-import { DuckDBArrayValue, DuckDBBitValue, DuckDBDateValue, DuckDBDecimalValue, DuckDBIntervalValue, DuckDBListValue, DuckDBMapValue, DuckDBStructValue, DuckDBTimestampMillisecondsValue, DuckDBTimestampNanosecondsValue, DuckDBTimestampSecondsValue, DuckDBTimestampTZValue, DuckDBTimestampValue, DuckDBTimeTZValue, DuckDBTimeValue, DuckDBUnionValue, DuckDBUUIDValue, DuckDBValue } from './values';
+import { DuckDBArrayValue, DuckDBBitValue, DuckDBDateValue, DuckDBDecimalValue, DuckDBIntervalValue, DuckDBListValue, DuckDBMapValue, DuckDBStructValue, DuckDBTimestampMillisecondsValue, DuckDBTimestampNanosecondsValue, DuckDBTimestampSecondsValue, DuckDBTimestampTZValue, DuckDBTimestampTZNanosecondsValue, DuckDBTimestampValue, DuckDBTimeTZValue, DuckDBTimeValue, DuckDBTupleValue, DuckDBUnionValue, DuckDBUUIDValue, DuckDBValue, DuckDBVariantValue } from './values';
 export declare class DuckDBPreparedStatement {
     private readonly prepared_statement;
     constructor(prepared_statement: duckdb.PreparedStatement);
@@ -42,6 +42,7 @@ export declare class DuckDBPreparedStatement {
     bindTimeTZ(parameterIndex: number, value: DuckDBTimeTZValue): void;
     bindTimestamp(parameterIndex: number, value: DuckDBTimestampValue): void;
     bindTimestampTZ(parameterIndex: number, value: DuckDBTimestampTZValue): void;
+    bindTimestampTZNanoseconds(parameterIndex: number, value: DuckDBTimestampTZNanosecondsValue): void;
     bindTimestampSeconds(parameterIndex: number, value: DuckDBTimestampSecondsValue): void;
     bindTimestampMilliseconds(parameterIndex: number, value: DuckDBTimestampMillisecondsValue): void;
     bindTimestampNanoseconds(parameterIndex: number, value: DuckDBTimestampNanosecondsValue): void;
@@ -52,10 +53,12 @@ export declare class DuckDBPreparedStatement {
     bindArray(parameterIndex: number, value: DuckDBArrayValue | readonly DuckDBValue[], type?: DuckDBArrayType): void;
     bindList(parameterIndex: number, value: DuckDBListValue | readonly DuckDBValue[], type?: DuckDBListType): void;
     bindStruct(parameterIndex: number, value: DuckDBStructValue | Readonly<Record<string, DuckDBValue>>, type?: DuckDBStructType): void;
+    bindTuple(parameterIndex: number, value: DuckDBTupleValue | readonly DuckDBValue[], type?: DuckDBStructType): void;
     bindMap(parameterIndex: number, value: DuckDBMapValue, type?: DuckDBMapType): void;
     bindUnion(parameterIndex: number, value: DuckDBUnionValue, type?: DuckDBUnionType): void;
     bindUUID(parameterIndex: number, value: DuckDBUUIDValue): void;
     bindBit(parameterIndex: number, value: DuckDBBitValue): void;
+    bindVariant(parameterIndex: number, value: DuckDBVariantValue | null): void;
     bindNull(parameterIndex: number): void;
     bindValue(parameterIndex: number, value: DuckDBValue, type?: DuckDBType): void;
     bind(values: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): void;

package/lib/DuckDBPreparedStatement.js

@@ -115,6 +115,9 @@ class DuckDBPreparedStatement {
     bindTimestampTZ(parameterIndex, value) {
         this.bindValue(parameterIndex, value, DuckDBType_1.TIMESTAMPTZ);
     }
+    bindTimestampTZNanoseconds(parameterIndex, value) {
+        this.bindValue(parameterIndex, value, DuckDBType_1.TIMESTAMPTZ_NS);
+    }
     bindTimestampSeconds(parameterIndex, value) {
         this.bindValue(parameterIndex, value, DuckDBType_1.TIMESTAMP_S);
     }
@@ -145,6 +148,9 @@ class DuckDBPreparedStatement {
     bindStruct(parameterIndex, value, type) {
         this.bindValue(parameterIndex, value instanceof values_1.DuckDBStructValue ? value : (0, values_1.structValue)(value), type);
     }
+    bindTuple(parameterIndex, value, type) {
+        this.bindValue(parameterIndex, value instanceof values_1.DuckDBTupleValue ? value : (0, values_1.tupleValue)(value), type);
+    }
     bindMap(parameterIndex, value, type) {
         this.bindValue(parameterIndex, value, type);
     }
@@ -157,6 +163,13 @@ class DuckDBPreparedStatement {
     bindBit(parameterIndex, value) {
         this.bindValue(parameterIndex, value, DuckDBType_1.BIT);
     }
+    bindVariant(parameterIndex, value) {
+        if (value === null) {
+            this.bindNull(parameterIndex);
+            return;
+        }
+        this.bindValue(parameterIndex, value, DuckDBType_1.VARIANT);
+    }
     bindNull(parameterIndex) {
         node_bindings_1.default.bind_null(this.prepared_statement, parameterIndex);
     }
@@ -178,7 +191,7 @@ class DuckDBPreparedStatement {
         }
     }
     async run() {
-        return new DuckDBMaterializedResult_1.DuckDBMaterializedResult(await node_bindings_1.default.execute_prepared(this.prepared_statement));
+        return new DuckDBMaterializedResult_1.DuckDBMaterializedResult(await node_bindings_1.default.execute_prepared(this.prepared_statement), this.statementType);
     }
     async runAndRead() {
         return new DuckDBResultReader_1.DuckDBResultReader(await this.run());
@@ -194,7 +207,7 @@ class DuckDBPreparedStatement {
         return reader;
     }
     async stream() {
-        return new DuckDBResult_1.DuckDBResult(await node_bindings_1.default.execute_prepared_streaming(this.prepared_statement));
+        return new DuckDBResult_1.DuckDBResult(await node_bindings_1.default.execute_prepared_streaming(this.prepared_statement), this.statementType);
     }
     async streamAndRead() {
         return new DuckDBResultReader_1.DuckDBResultReader(await this.stream());
@@ -210,10 +223,10 @@ class DuckDBPreparedStatement {
         return reader;
     }
     start() {
-        return new DuckDBPendingResult_1.DuckDBPendingResult(node_bindings_1.default.pending_prepared(this.prepared_statement));
+        return new DuckDBPendingResult_1.DuckDBPendingResult(node_bindings_1.default.pending_prepared(this.prepared_statement), this.statementType);
     }
     startStream() {
-        return new DuckDBPendingResult_1.DuckDBPendingResult(node_bindings_1.default.pending_prepared_streaming(this.prepared_statement));
+        return new DuckDBPendingResult_1.DuckDBPendingResult(node_bindings_1.default.pending_prepared_streaming(this.prepared_statement), this.statementType);
     }
 }
 exports.DuckDBPreparedStatement = DuckDBPreparedStatement;

package/lib/DuckDBResult.d.ts

@@ -10,7 +10,25 @@ import { ResultReturnType, StatementType } from './enums';
 import { DuckDBValue } from './values';
 export declare class DuckDBResult {
     protected readonly result: duckdb.Result;
-    constructor(result: duckdb.Result);
+    private readonly preparedStatementType;
+    private closedMetadata;
+    /**
+     * `preparedStatementType` is the type of the prepared statement the result
+     * came from, if any. It is reported as the result's statement type when
+     * DuckDB reports EXECUTE instead.
+     */
+    constructor(result: duckdb.Result, preparedStatementType?: StatementType);
+    /**
+     * Destroys the result, freeing its memory. On DuckDB 2.0, a streaming result
+     * that has not been read to the end blocks its connection from starting
+     * another statement until it is closed.
+     *
+     * The return type, statement type, column names and types, and rows changed
+     * stay available; fetching throws. If a fetch is in flight, the result is
+     * destroyed, and its connection unblocked, only once that fetch finishes.
+     * Closing again does nothing.
+     */
+    closeSync(): void;
     get returnType(): ResultReturnType;
     get statementType(): StatementType;
     get columnCount(): number;
@@ -54,4 +72,6 @@ export declare class DuckDBResult {
     yieldRowsJson(): AsyncIterableIterator<Json[][]>;
     yieldRowObjectJs(): AsyncIterableIterator<Record<string, JS>[]>;
     yieldRowObjectJson(): AsyncIterableIterator<Record<string, Json>[]>;
+    /** Converts the index as the bindings do (ToUint32), then checks range. */
+    private checkClosedColumnIndex;
 }