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

package/lib/DuckDBResult.js

@@ -13,25 +13,83 @@ const convertColumnsFromChunks_1 = require("./convertColumnsFromChunks");
 const convertColumnsObjectFromChunks_1 = require("./convertColumnsObjectFromChunks");
 const convertRowObjectsFromChunks_1 = require("./convertRowObjectsFromChunks");
 const convertRowsFromChunks_1 = require("./convertRowsFromChunks");
+const enums_1 = require("./enums");
 const getColumnsFromChunks_1 = require("./getColumnsFromChunks");
 const getColumnsObjectFromChunks_1 = require("./getColumnsObjectFromChunks");
 const getRowObjectsFromChunks_1 = require("./getRowObjectsFromChunks");
 const getRowsFromChunks_1 = require("./getRowsFromChunks");
 class DuckDBResult {
     result;
-    constructor(result) {
+    preparedStatementType;
+    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, preparedStatementType) {
         this.result = result;
+        this.preparedStatementType = preparedStatementType;
+    }
+    /**
+     * 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() {
+        if (!this.closedMetadata) {
+            const columnCount = this.columnCount;
+            const columnNames = [];
+            const columnTypes = [];
+            for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+                columnNames.push(this.columnName(columnIndex));
+                columnTypes.push(this.columnType(columnIndex));
+            }
+            this.closedMetadata = {
+                returnType: this.returnType,
+                statementType: this.statementType,
+                columnNames,
+                columnTypes,
+                isStreaming: this.isStreaming,
+                rowsChanged: this.rowsChanged,
+            };
+        }
+        node_bindings_1.default.destroy_result_sync(this.result);
     }
     get returnType() {
+        if (this.closedMetadata) {
+            return this.closedMetadata.returnType;
+        }
         return node_bindings_1.default.result_return_type(this.result);
     }
     get statementType() {
-        return node_bindings_1.default.result_statement_type(this.result);
+        if (this.closedMetadata) {
+            return this.closedMetadata.statementType;
+        }
+        const statementType = node_bindings_1.default.result_statement_type(this.result);
+        // On DuckDB 2.0, results of prepared statements report EXECUTE; see
+        // https://github.com/duckdb/duckdb/issues/27415
+        if (statementType === enums_1.StatementType.EXECUTE &&
+            this.preparedStatementType !== undefined) {
+            return this.preparedStatementType;
+        }
+        return statementType;
     }
     get columnCount() {
+        if (this.closedMetadata) {
+            return this.closedMetadata.columnNames.length;
+        }
         return node_bindings_1.default.column_count(this.result);
     }
     columnName(columnIndex) {
+        if (this.closedMetadata) {
+            return this.closedMetadata.columnNames[this.checkClosedColumnIndex(columnIndex)];
+        }
         return node_bindings_1.default.column_name(this.result, columnIndex);
     }
     columnNames() {
@@ -60,13 +118,22 @@ class DuckDBResult {
         return outputColumnNames;
     }
     columnTypeId(columnIndex) {
+        if (this.closedMetadata) {
+            return this.columnType(columnIndex).typeId;
+        }
         return node_bindings_1.default.column_type(this.result, columnIndex);
     }
     columnLogicalType(columnIndex) {
+        if (this.closedMetadata) {
+            return this.columnType(columnIndex).toLogicalType();
+        }
         return DuckDBLogicalType_1.DuckDBLogicalType.create(node_bindings_1.default.column_logical_type(this.result, columnIndex));
     }
     columnType(columnIndex) {
-        return DuckDBLogicalType_1.DuckDBLogicalType.create(node_bindings_1.default.column_logical_type(this.result, columnIndex)).asType();
+        if (this.closedMetadata) {
+            return this.closedMetadata.columnTypes[this.checkClosedColumnIndex(columnIndex)];
+        }
+        return this.columnLogicalType(columnIndex).asType();
     }
     columnTypeJson(columnIndex) {
         return this.columnType(columnIndex).toJson();
@@ -105,9 +172,15 @@ class DuckDBResult {
         return columnNameAndTypeObjects;
     }
     get isStreaming() {
+        if (this.closedMetadata) {
+            return this.closedMetadata.isStreaming;
+        }
         return node_bindings_1.default.result_is_streaming(this.result);
     }
     get rowsChanged() {
+        if (this.closedMetadata) {
+            return this.closedMetadata.rowsChanged;
+        }
         return node_bindings_1.default.rows_changed(this.result);
     }
     async fetchChunk() {
@@ -126,11 +199,11 @@ class DuckDBResult {
     }
     async getColumns() {
         const chunks = await this.fetchAllChunks();
-        return (0, getColumnsFromChunks_1.getColumnsFromChunks)(chunks);
+        return (0, getColumnsFromChunks_1.getColumnsFromChunks)(chunks, this.columnCount);
     }
     async convertColumns(converter) {
         const chunks = await this.fetchAllChunks();
-        return (0, convertColumnsFromChunks_1.convertColumnsFromChunks)(chunks, converter);
+        return (0, convertColumnsFromChunks_1.convertColumnsFromChunks)(chunks, this.columnCount, converter);
     }
     async getColumnsJS() {
         return this.convertColumns(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
@@ -225,5 +298,14 @@ class DuckDBResult {
     yieldRowObjectJson() {
         return this.yieldConvertedRowObjects(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
     }
+    /** Converts the index as the bindings do (ToUint32), then checks range. */
+    checkClosedColumnIndex(columnIndex) {
+        const index = columnIndex >>> 0;
+        const columnCount = this.closedMetadata?.columnNames.length ?? 0;
+        if (index >= columnCount) {
+            throw new RangeError(`column index ${index} is out of range (count: ${columnCount})`);
+        }
+        return index;
+    }
 }
 exports.DuckDBResult = DuckDBResult;

package/lib/DuckDBResultReader.d.ts

@@ -14,6 +14,11 @@ export declare class DuckDBResultReader {
     private currentRowCount_;
     private done_;
     constructor(result: DuckDBResult);
+    /**
+     * Closes the result being read; see `DuckDBResult.closeSync`. Rows already
+     * read and the column metadata stay available; reading more throws.
+     */
+    closeSync(): void;
     get returnType(): ResultReturnType;
     get statementType(): StatementType;
     get columnCount(): number;

package/lib/DuckDBResultReader.js

@@ -24,6 +24,13 @@ class DuckDBResultReader {
         this.currentRowCount_ = 0;
         this.done_ = false;
     }
+    /**
+     * Closes the result being read; see `DuckDBResult.closeSync`. Rows already
+     * read and the column metadata stay available; reading more throws.
+     */
+    closeSync() {
+        this.result.closeSync();
+    }
     get returnType() {
         return this.result.returnType;
     }
@@ -152,10 +159,10 @@ class DuckDBResultReader {
         });
     }
     getColumns() {
-        return (0, getColumnsFromChunks_1.getColumnsFromChunks)(this.chunks);
+        return (0, getColumnsFromChunks_1.getColumnsFromChunks)(this.chunks, this.columnCount);
     }
     convertColumns(converter) {
-        return (0, convertColumnsFromChunks_1.convertColumnsFromChunks)(this.chunks, converter);
+        return (0, convertColumnsFromChunks_1.convertColumnsFromChunks)(this.chunks, this.columnCount, converter);
     }
     getColumnsJS() {
         return this.convertColumns(JSDuckDBValueConverter_1.JSDuckDBValueConverter);

package/lib/DuckDBScalarFunction.d.ts

@@ -1,17 +1,20 @@
 import duckdb from '@haybarn/node-bindings';
 import { DuckDBDataChunk } from './DuckDBDataChunk';
-import { DuckDBFunctionInfo } from './DuckDBFunctionInfo';
+import { DuckDBScalarFunctionBindInfo } from './DuckDBScalarFunctionBindInfo';
+import { DuckDBScalarFunctionInfo } from './DuckDBScalarFunctionInfo';
+import { DuckDBScalarFunctionInitInfo } from './DuckDBScalarFunctionInitInfo';
 import { DuckDBType } from './DuckDBType';
 import { DuckDBVector } from './DuckDBVector';
-import { DuckDBBindInfo } from './DuckDBBindInfo';
-export type DuckDBScalarBindFunction = (bindInfo: DuckDBBindInfo) => void;
-export type DuckDBScalarMainFunction = (functionInfo: DuckDBFunctionInfo, inputDataChunk: DuckDBDataChunk, outputVector: DuckDBVector) => void;
+export type DuckDBScalarBindFunction = (bindInfo: DuckDBScalarFunctionBindInfo) => void;
+export type DuckDBScalarInitFunction = (initInfo: DuckDBScalarFunctionInitInfo) => void;
+export type DuckDBScalarMainFunction = (functionInfo: DuckDBScalarFunctionInfo, inputDataChunk: DuckDBDataChunk, outputVector: DuckDBVector) => void;
 export declare class DuckDBScalarFunction {
     readonly scalar_function: duckdb.ScalarFunction;
     constructor();
-    static create({ name, bindFunction, mainFunction, returnType, parameterTypes, varArgsType, specialHandling, volatile, extraInfo, }: {
+    static create({ name, bindFunction, initFunction, mainFunction, returnType, parameterTypes, varArgsType, specialHandling, volatile, extraInfo, }: {
         name: string;
         bindFunction?: DuckDBScalarBindFunction;
+        initFunction?: DuckDBScalarInitFunction;
         mainFunction: DuckDBScalarMainFunction;
         returnType: DuckDBType;
         parameterTypes?: readonly DuckDBType[];
@@ -23,6 +26,7 @@ export declare class DuckDBScalarFunction {
     destroySync(): void;
     setName(name: string): void;
     setBindFunction(bindFunction: DuckDBScalarBindFunction): void;
+    setInitFunction(initFunction: DuckDBScalarInitFunction): void;
     setMainFunction(mainFunction: DuckDBScalarMainFunction): void;
     setReturnType(returnType: DuckDBType): void;
     addParameter(parameterType: DuckDBType): void;

package/lib/DuckDBScalarFunction.js

@@ -6,20 +6,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DuckDBScalarFunction = void 0;
 const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
 const DuckDBDataChunk_1 = require("./DuckDBDataChunk");
-const DuckDBFunctionInfo_1 = require("./DuckDBFunctionInfo");
+const DuckDBScalarFunctionBindInfo_1 = require("./DuckDBScalarFunctionBindInfo");
+const DuckDBScalarFunctionInfo_1 = require("./DuckDBScalarFunctionInfo");
+const DuckDBScalarFunctionInitInfo_1 = require("./DuckDBScalarFunctionInitInfo");
 const DuckDBVector_1 = require("./DuckDBVector");
-const DuckDBBindInfo_1 = require("./DuckDBBindInfo");
 class DuckDBScalarFunction {
     scalar_function;
     constructor() {
         this.scalar_function = node_bindings_1.default.create_scalar_function();
     }
-    static create({ name, bindFunction, mainFunction, returnType, parameterTypes, varArgsType, specialHandling, volatile, extraInfo, }) {
+    static create({ name, bindFunction, initFunction, mainFunction, returnType, parameterTypes, varArgsType, specialHandling, volatile, extraInfo, }) {
         const scalarFunction = new DuckDBScalarFunction();
         scalarFunction.setName(name);
         if (bindFunction) {
             scalarFunction.setBindFunction(bindFunction);
         }
+        if (initFunction) {
+            scalarFunction.setInitFunction(initFunction);
+        }
         scalarFunction.setMainFunction(mainFunction);
         scalarFunction.setReturnType(returnType);
         if (parameterTypes) {
@@ -49,13 +53,18 @@ class DuckDBScalarFunction {
     }
     setBindFunction(bindFunction) {
         node_bindings_1.default.scalar_function_set_bind(this.scalar_function, (info) => {
-            const bindInfo = new DuckDBBindInfo_1.DuckDBBindInfo(info);
+            const bindInfo = new DuckDBScalarFunctionBindInfo_1.DuckDBScalarFunctionBindInfo(info);
             bindFunction(bindInfo);
         });
     }
+    setInitFunction(initFunction) {
+        node_bindings_1.default.scalar_function_set_init(this.scalar_function, (info) => {
+            initFunction(new DuckDBScalarFunctionInitInfo_1.DuckDBScalarFunctionInitInfo(info));
+        });
+    }
     setMainFunction(mainFunction) {
         node_bindings_1.default.scalar_function_set_function(this.scalar_function, (info, input, output) => {
-            const functionInfo = new DuckDBFunctionInfo_1.DuckDBFunctionInfo(info);
+            const functionInfo = new DuckDBScalarFunctionInfo_1.DuckDBScalarFunctionInfo(info);
             const inputDataChunk = new DuckDBDataChunk_1.DuckDBDataChunk(input);
             const outputVector = DuckDBVector_1.DuckDBVector.create(output, inputDataChunk.rowCount);
             mainFunction(functionInfo, inputDataChunk, outputVector);

package/lib/DuckDBScalarFunctionBindInfo.d.ts

@@ -0,0 +1,16 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBClientContext } from './DuckDBClientContext';
+export declare class DuckDBScalarFunctionBindInfo {
+    private readonly bind_info;
+    constructor(bind_info: duckdb.ScalarFunctionBindInfo);
+    get clientContext(): DuckDBClientContext;
+    getClientContext(): DuckDBClientContext;
+    get extraInfo(): object | undefined;
+    getExtraInfo(): object | undefined;
+    setBindData(bindData: object): void;
+    setError(error: string): void;
+}
+/** @deprecated Renamed to DuckDBScalarFunctionBindInfo. */
+export declare const DuckDBBindInfo: typeof DuckDBScalarFunctionBindInfo;
+/** @deprecated Renamed to DuckDBScalarFunctionBindInfo. */
+export type DuckDBBindInfo = DuckDBScalarFunctionBindInfo;

package/lib/{DuckDBBindInfo.js → DuckDBScalarFunctionBindInfo.js}

@@ -3,10 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DuckDBBindInfo = void 0;
+exports.DuckDBBindInfo = exports.DuckDBScalarFunctionBindInfo = void 0;
 const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
 const DuckDBClientContext_1 = require("./DuckDBClientContext");
-class DuckDBBindInfo {
+class DuckDBScalarFunctionBindInfo {
     bind_info;
     constructor(bind_info) {
         this.bind_info = bind_info;
@@ -30,4 +30,6 @@ class DuckDBBindInfo {
         node_bindings_1.default.scalar_function_bind_set_error(this.bind_info, error);
     }
 }
-exports.DuckDBBindInfo = DuckDBBindInfo;
+exports.DuckDBScalarFunctionBindInfo = DuckDBScalarFunctionBindInfo;
+/** @deprecated Renamed to DuckDBScalarFunctionBindInfo. */
+exports.DuckDBBindInfo = DuckDBScalarFunctionBindInfo;

package/lib/DuckDBScalarFunctionInfo.d.ts

@@ -0,0 +1,16 @@
+import duckdb from '@haybarn/node-bindings';
+export declare class DuckDBScalarFunctionInfo {
+    private readonly function_info;
+    constructor(function_info: duckdb.ScalarFunctionInfo);
+    get bindData(): object | undefined;
+    getBindData(): object | undefined;
+    get extraInfo(): object | undefined;
+    getExtraInfo(): object | undefined;
+    get state(): object | undefined;
+    getState(): object | undefined;
+    setError(error: string): void;
+}
+/** @deprecated Renamed to DuckDBScalarFunctionInfo. */
+export declare const DuckDBFunctionInfo: typeof DuckDBScalarFunctionInfo;
+/** @deprecated Renamed to DuckDBScalarFunctionInfo. */
+export type DuckDBFunctionInfo = DuckDBScalarFunctionInfo;

package/lib/{DuckDBFunctionInfo.js → DuckDBScalarFunctionInfo.js}

@@ -3,9 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DuckDBFunctionInfo = void 0;
+exports.DuckDBFunctionInfo = exports.DuckDBScalarFunctionInfo = void 0;
 const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
-class DuckDBFunctionInfo {
+class DuckDBScalarFunctionInfo {
     function_info;
     constructor(function_info) {
         this.function_info = function_info;
@@ -22,8 +22,16 @@ class DuckDBFunctionInfo {
     getExtraInfo() {
         return node_bindings_1.default.scalar_function_get_extra_info(this.function_info);
     }
+    get state() {
+        return this.getState();
+    }
+    getState() {
+        return node_bindings_1.default.scalar_function_get_state(this.function_info);
+    }
     setError(error) {
         node_bindings_1.default.scalar_function_set_error(this.function_info, error);
     }
 }
-exports.DuckDBFunctionInfo = DuckDBFunctionInfo;
+exports.DuckDBScalarFunctionInfo = DuckDBScalarFunctionInfo;
+/** @deprecated Renamed to DuckDBScalarFunctionInfo. */
+exports.DuckDBFunctionInfo = DuckDBScalarFunctionInfo;

package/lib/{DuckDBBindInfo.d.ts → DuckDBScalarFunctionInitInfo.d.ts}

@@ -1,12 +1,14 @@
 import duckdb from '@haybarn/node-bindings';
 import { DuckDBClientContext } from './DuckDBClientContext';
-export declare class DuckDBBindInfo {
-    private readonly bind_info;
-    constructor(bind_info: duckdb.BindInfo);
+export declare class DuckDBScalarFunctionInitInfo {
+    private readonly init_info;
+    constructor(init_info: duckdb.ScalarFunctionInitInfo);
     get clientContext(): DuckDBClientContext;
     getClientContext(): DuckDBClientContext;
     get extraInfo(): object | undefined;
     getExtraInfo(): object | undefined;
-    setBindData(bindData: object): void;
+    get bindData(): object | undefined;
+    getBindData(): object | undefined;
+    setState(state: object): void;
     setError(error: string): void;
 }

package/lib/DuckDBScalarFunctionInitInfo.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBScalarFunctionInitInfo = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBClientContext_1 = require("./DuckDBClientContext");
+class DuckDBScalarFunctionInitInfo {
+    init_info;
+    constructor(init_info) {
+        this.init_info = init_info;
+    }
+    get clientContext() {
+        return this.getClientContext();
+    }
+    getClientContext() {
+        return new DuckDBClientContext_1.DuckDBClientContext(node_bindings_1.default.scalar_function_init_get_client_context(this.init_info));
+    }
+    get extraInfo() {
+        return this.getExtraInfo();
+    }
+    getExtraInfo() {
+        return node_bindings_1.default.scalar_function_init_get_extra_info(this.init_info);
+    }
+    get bindData() {
+        return this.getBindData();
+    }
+    getBindData() {
+        return node_bindings_1.default.scalar_function_init_get_bind_data(this.init_info);
+    }
+    setState(state) {
+        node_bindings_1.default.scalar_function_init_set_state(this.init_info, state);
+    }
+    setError(error) {
+        node_bindings_1.default.scalar_function_init_set_error(this.init_info, error);
+    }
+}
+exports.DuckDBScalarFunctionInitInfo = DuckDBScalarFunctionInitInfo;

package/lib/DuckDBTableFunction.d.ts

@@ -0,0 +1,41 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBTableFunctionBindInfo } from './DuckDBTableFunctionBindInfo';
+import { DuckDBTableFunctionInfo } from './DuckDBTableFunctionInfo';
+import { DuckDBTableFunctionInitInfo } from './DuckDBTableFunctionInitInfo';
+import { DuckDBType } from './DuckDBType';
+export type DuckDBTableBindFunction = (bindInfo: DuckDBTableFunctionBindInfo) => void;
+export type DuckDBTableInitFunction = (initInfo: DuckDBTableFunctionInitInfo) => void;
+/**
+ * Produces one chunk of the scan per call.
+ *
+ * Set `outputDataChunk.rowCount` before writing, then write that many rows to
+ * each column vector. A row count of zero reports that the scan is finished, so
+ * a function that never sets zero never terminates.
+ */
+export type DuckDBTableMainFunction = (functionInfo: DuckDBTableFunctionInfo, outputDataChunk: DuckDBDataChunk) => void;
+export declare class DuckDBTableFunction {
+    readonly table_function: duckdb.TableFunction;
+    constructor();
+    static create({ name, bindFunction, initFunction, localInitFunction, mainFunction, parameterTypes, namedParameterTypes, supportsProjectionPushdown, extraInfo, }: {
+        name: string;
+        bindFunction: DuckDBTableBindFunction;
+        initFunction: DuckDBTableInitFunction;
+        localInitFunction?: DuckDBTableInitFunction;
+        mainFunction: DuckDBTableMainFunction;
+        parameterTypes?: readonly DuckDBType[];
+        namedParameterTypes?: Readonly<Record<string, DuckDBType>>;
+        supportsProjectionPushdown?: boolean;
+        extraInfo?: object;
+    }): DuckDBTableFunction;
+    destroySync(): void;
+    setName(name: string): void;
+    setBindFunction(bindFunction: DuckDBTableBindFunction): void;
+    setInitFunction(initFunction: DuckDBTableInitFunction): void;
+    setLocalInitFunction(localInitFunction: DuckDBTableInitFunction): void;
+    setMainFunction(mainFunction: DuckDBTableMainFunction): void;
+    addParameter(parameterType: DuckDBType): void;
+    addNamedParameter(name: string, parameterType: DuckDBType): void;
+    setSupportsProjectionPushdown(pushdown: boolean): void;
+    setExtraInfo(extraInfo: object): void;
+}

package/lib/DuckDBTableFunction.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTableFunction = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBDataChunk_1 = require("./DuckDBDataChunk");
+const DuckDBTableFunctionBindInfo_1 = require("./DuckDBTableFunctionBindInfo");
+const DuckDBTableFunctionInfo_1 = require("./DuckDBTableFunctionInfo");
+const DuckDBTableFunctionInitInfo_1 = require("./DuckDBTableFunctionInitInfo");
+class DuckDBTableFunction {
+    table_function;
+    constructor() {
+        this.table_function = node_bindings_1.default.create_table_function();
+    }
+    static create({ name, bindFunction, initFunction, localInitFunction, mainFunction, parameterTypes, namedParameterTypes, supportsProjectionPushdown, extraInfo, }) {
+        const tableFunction = new DuckDBTableFunction();
+        tableFunction.setName(name);
+        tableFunction.setBindFunction(bindFunction);
+        tableFunction.setInitFunction(initFunction);
+        if (localInitFunction) {
+            tableFunction.setLocalInitFunction(localInitFunction);
+        }
+        tableFunction.setMainFunction(mainFunction);
+        if (parameterTypes) {
+            for (const parameterType of parameterTypes) {
+                tableFunction.addParameter(parameterType);
+            }
+        }
+        if (namedParameterTypes) {
+            for (const [parameterName, parameterType,] of Object.entries(namedParameterTypes)) {
+                tableFunction.addNamedParameter(parameterName, parameterType);
+            }
+        }
+        if (supportsProjectionPushdown) {
+            tableFunction.setSupportsProjectionPushdown(true);
+        }
+        if (extraInfo) {
+            tableFunction.setExtraInfo(extraInfo);
+        }
+        return tableFunction;
+    }
+    destroySync() {
+        node_bindings_1.default.destroy_table_function_sync(this.table_function);
+    }
+    setName(name) {
+        node_bindings_1.default.table_function_set_name(this.table_function, name);
+    }
+    setBindFunction(bindFunction) {
+        node_bindings_1.default.table_function_set_bind(this.table_function, (info) => {
+            bindFunction(new DuckDBTableFunctionBindInfo_1.DuckDBTableFunctionBindInfo(info));
+        });
+    }
+    setInitFunction(initFunction) {
+        node_bindings_1.default.table_function_set_init(this.table_function, (info) => {
+            initFunction(new DuckDBTableFunctionInitInfo_1.DuckDBTableFunctionInitInfo(info));
+        });
+    }
+    setLocalInitFunction(localInitFunction) {
+        node_bindings_1.default.table_function_set_local_init(this.table_function, (info) => {
+            localInitFunction(new DuckDBTableFunctionInitInfo_1.DuckDBTableFunctionInitInfo(info));
+        });
+    }
+    setMainFunction(mainFunction) {
+        node_bindings_1.default.table_function_set_function(this.table_function, (info, output) => {
+            mainFunction(new DuckDBTableFunctionInfo_1.DuckDBTableFunctionInfo(info), new DuckDBDataChunk_1.DuckDBDataChunk(output));
+        });
+    }
+    addParameter(parameterType) {
+        node_bindings_1.default.table_function_add_parameter(this.table_function, parameterType.toLogicalType().logical_type);
+    }
+    addNamedParameter(name, parameterType) {
+        node_bindings_1.default.table_function_add_named_parameter(this.table_function, name, parameterType.toLogicalType().logical_type);
+    }
+    setSupportsProjectionPushdown(pushdown) {
+        node_bindings_1.default.table_function_supports_projection_pushdown(this.table_function, pushdown);
+    }
+    setExtraInfo(extraInfo) {
+        node_bindings_1.default.table_function_set_extra_info(this.table_function, extraInfo);
+    }
+}
+exports.DuckDBTableFunction = DuckDBTableFunction;

package/lib/DuckDBTableFunctionBindInfo.d.ts

@@ -0,0 +1,21 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBClientContext } from './DuckDBClientContext';
+import { DuckDBType } from './DuckDBType';
+import { DuckDBValue } from './values';
+export declare class DuckDBTableFunctionBindInfo {
+    private readonly bind_info;
+    constructor(bind_info: duckdb.TableFunctionBindInfo);
+    get clientContext(): DuckDBClientContext;
+    getClientContext(): DuckDBClientContext;
+    get extraInfo(): object | undefined;
+    getExtraInfo(): object | undefined;
+    get parameterCount(): number;
+    getParameterCount(): number;
+    getParameter(index: number): DuckDBValue;
+    /** Returns null if no parameter with this name was supplied. */
+    getNamedParameter(name: string): DuckDBValue | null;
+    addResultColumn(name: string, type: DuckDBType): void;
+    setBindData(bindData: object): void;
+    setCardinality(cardinality: number, isExact: boolean): void;
+    setError(error: string): void;
+}

package/lib/DuckDBTableFunctionBindInfo.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTableFunctionBindInfo = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBClientContext_1 = require("./DuckDBClientContext");
+const readValue_1 = require("./readValue");
+class DuckDBTableFunctionBindInfo {
+    bind_info;
+    constructor(bind_info) {
+        this.bind_info = bind_info;
+    }
+    get clientContext() {
+        return this.getClientContext();
+    }
+    getClientContext() {
+        return new DuckDBClientContext_1.DuckDBClientContext(node_bindings_1.default.table_function_get_client_context(this.bind_info));
+    }
+    get extraInfo() {
+        return this.getExtraInfo();
+    }
+    getExtraInfo() {
+        return node_bindings_1.default.bind_get_extra_info(this.bind_info);
+    }
+    get parameterCount() {
+        return this.getParameterCount();
+    }
+    getParameterCount() {
+        return node_bindings_1.default.bind_get_parameter_count(this.bind_info);
+    }
+    getParameter(index) {
+        return (0, readValue_1.readValue)(node_bindings_1.default.bind_get_parameter(this.bind_info, index));
+    }
+    /** Returns null if no parameter with this name was supplied. */
+    getNamedParameter(name) {
+        const value = node_bindings_1.default.bind_get_named_parameter(this.bind_info, name);
+        return value === null ? null : (0, readValue_1.readValue)(value);
+    }
+    addResultColumn(name, type) {
+        node_bindings_1.default.bind_add_result_column(this.bind_info, name, type.toLogicalType().logical_type);
+    }
+    setBindData(bindData) {
+        node_bindings_1.default.bind_set_bind_data(this.bind_info, bindData);
+    }
+    setCardinality(cardinality, isExact) {
+        node_bindings_1.default.bind_set_cardinality(this.bind_info, cardinality, isExact);
+    }
+    setError(error) {
+        node_bindings_1.default.bind_set_error(this.bind_info, error);
+    }
+}
+exports.DuckDBTableFunctionBindInfo = DuckDBTableFunctionBindInfo;

package/lib/DuckDBTableFunctionInfo.d.ts

@@ -0,0 +1,15 @@
+import duckdb from '@haybarn/node-bindings';
+export declare class DuckDBTableFunctionInfo {
+    private readonly function_info;
+    constructor(function_info: duckdb.TableFunctionInfo);
+    get extraInfo(): object | undefined;
+    getExtraInfo(): object | undefined;
+    get bindData(): object | undefined;
+    getBindData(): object | undefined;
+    get initData(): object | undefined;
+    getInitData(): object | undefined;
+    /** The init data set by the local init function, which is per scanning thread. */
+    get localInitData(): object | undefined;
+    getLocalInitData(): object | undefined;
+    setError(error: string): void;
+}