@haybarn/node-api 1.5.3-rc2

package/lib/DuckDBAppender.d.ts

@@ -0,0 +1,51 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBArrayType, DuckDBEnumType, DuckDBListType, DuckDBMapType, DuckDBStructType, DuckDBType, DuckDBUnionType } from './DuckDBType';
+import { DuckDBArrayValue, DuckDBBitValue, DuckDBDateValue, DuckDBDecimalValue, DuckDBIntervalValue, DuckDBListValue, DuckDBMapValue, DuckDBStructValue, DuckDBTimestampMillisecondsValue, DuckDBTimestampNanosecondsValue, DuckDBTimestampSecondsValue, DuckDBTimestampTZValue, DuckDBTimestampValue, DuckDBTimeTZValue, DuckDBTimeValue, DuckDBUnionValue, DuckDBUUIDValue, DuckDBValue } from './values';
+export declare class DuckDBAppender {
+    private readonly appender;
+    constructor(appender: duckdb.Appender);
+    closeSync(): void;
+    flushSync(): void;
+    get columnCount(): number;
+    columnType(columnIndex: number): DuckDBType;
+    endRow(): void;
+    appendDefault(): void;
+    appendBoolean(value: boolean): void;
+    appendTinyInt(value: number): void;
+    appendSmallInt(value: number): void;
+    appendInteger(value: number): void;
+    appendBigInt(value: bigint): void;
+    appendHugeInt(value: bigint): void;
+    appendUTinyInt(value: number): void;
+    appendUSmallInt(value: number): void;
+    appendUInteger(value: number): void;
+    appendUBigInt(value: bigint): void;
+    appendUHugeInt(value: bigint): void;
+    appendDecimal(value: DuckDBDecimalValue): void;
+    appendFloat(value: number): void;
+    appendDouble(value: number): void;
+    appendDate(value: DuckDBDateValue): void;
+    appendTime(value: DuckDBTimeValue): void;
+    appendTimeTZ(value: DuckDBTimeTZValue): void;
+    appendTimestamp(value: DuckDBTimestampValue): void;
+    appendTimestampTZ(value: DuckDBTimestampTZValue): void;
+    appendTimestampSeconds(value: DuckDBTimestampSecondsValue): void;
+    appendTimestampMilliseconds(value: DuckDBTimestampMillisecondsValue): void;
+    appendTimestampNanoseconds(value: DuckDBTimestampNanosecondsValue): void;
+    appendInterval(value: DuckDBIntervalValue): void;
+    appendVarchar(value: string): void;
+    appendBlob(value: Uint8Array): void;
+    appendEnum(value: string, type: DuckDBEnumType): void;
+    appendList(value: DuckDBListValue | readonly DuckDBValue[], type?: DuckDBListType): void;
+    appendStruct(value: DuckDBStructValue | Readonly<Record<string, DuckDBValue>>, type?: DuckDBStructType): void;
+    appendMap(value: DuckDBMapValue, type?: DuckDBMapType): void;
+    appendArray(value: DuckDBArrayValue | readonly DuckDBValue[], type?: DuckDBArrayType): void;
+    appendUnion(value: DuckDBUnionValue, type?: DuckDBUnionType): void;
+    appendUUID(value: DuckDBUUIDValue): void;
+    appendBit(value: DuckDBBitValue): void;
+    appendBigNum(value: bigint): void;
+    appendNull(): void;
+    appendValue(value: DuckDBValue, type?: DuckDBType): void;
+    appendDataChunk(dataChunk: DuckDBDataChunk): void;
+}

package/lib/DuckDBAppender.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBAppender = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const createValue_1 = require("./createValue");
+const DuckDBLogicalType_1 = require("./DuckDBLogicalType");
+const DuckDBType_1 = require("./DuckDBType");
+const typeForValue_1 = require("./typeForValue");
+const values_1 = require("./values");
+class DuckDBAppender {
+    appender;
+    constructor(appender) {
+        this.appender = appender;
+    }
+    closeSync() {
+        node_bindings_1.default.appender_close_sync(this.appender);
+    }
+    flushSync() {
+        node_bindings_1.default.appender_flush_sync(this.appender);
+    }
+    get columnCount() {
+        return node_bindings_1.default.appender_column_count(this.appender);
+    }
+    columnType(columnIndex) {
+        return DuckDBLogicalType_1.DuckDBLogicalType.create(node_bindings_1.default.appender_column_type(this.appender, columnIndex)).asType();
+    }
+    endRow() {
+        node_bindings_1.default.appender_end_row(this.appender);
+    }
+    appendDefault() {
+        node_bindings_1.default.append_default(this.appender);
+    }
+    appendBoolean(value) {
+        node_bindings_1.default.append_bool(this.appender, value);
+    }
+    appendTinyInt(value) {
+        node_bindings_1.default.append_int8(this.appender, value);
+    }
+    appendSmallInt(value) {
+        node_bindings_1.default.append_int16(this.appender, value);
+    }
+    appendInteger(value) {
+        node_bindings_1.default.append_int32(this.appender, value);
+    }
+    appendBigInt(value) {
+        node_bindings_1.default.append_int64(this.appender, value);
+    }
+    appendHugeInt(value) {
+        node_bindings_1.default.append_hugeint(this.appender, value);
+    }
+    appendUTinyInt(value) {
+        node_bindings_1.default.append_uint8(this.appender, value);
+    }
+    appendUSmallInt(value) {
+        node_bindings_1.default.append_uint16(this.appender, value);
+    }
+    appendUInteger(value) {
+        node_bindings_1.default.append_uint32(this.appender, value);
+    }
+    appendUBigInt(value) {
+        node_bindings_1.default.append_uint64(this.appender, value);
+    }
+    appendUHugeInt(value) {
+        node_bindings_1.default.append_uhugeint(this.appender, value);
+    }
+    appendDecimal(value) {
+        // The width and scale of the DECIMAL type here aren't actually used.
+        this.appendValue(value, (0, DuckDBType_1.DECIMAL)(value.width, value.scale));
+    }
+    appendFloat(value) {
+        node_bindings_1.default.append_float(this.appender, value);
+    }
+    appendDouble(value) {
+        node_bindings_1.default.append_double(this.appender, value);
+    }
+    appendDate(value) {
+        node_bindings_1.default.append_date(this.appender, value);
+    }
+    appendTime(value) {
+        node_bindings_1.default.append_time(this.appender, value);
+    }
+    appendTimeTZ(value) {
+        this.appendValue(value, DuckDBType_1.TIMETZ);
+    }
+    appendTimestamp(value) {
+        node_bindings_1.default.append_timestamp(this.appender, value);
+    }
+    appendTimestampTZ(value) {
+        this.appendValue(value, DuckDBType_1.TIMESTAMPTZ);
+    }
+    appendTimestampSeconds(value) {
+        this.appendValue(value, DuckDBType_1.TIMESTAMP_S);
+    }
+    appendTimestampMilliseconds(value) {
+        this.appendValue(value, DuckDBType_1.TIMESTAMP_MS);
+    }
+    appendTimestampNanoseconds(value) {
+        this.appendValue(value, DuckDBType_1.TIMESTAMP_NS);
+    }
+    appendInterval(value) {
+        node_bindings_1.default.append_interval(this.appender, value);
+    }
+    appendVarchar(value) {
+        node_bindings_1.default.append_varchar(this.appender, value);
+    }
+    appendBlob(value) {
+        node_bindings_1.default.append_blob(this.appender, value);
+    }
+    appendEnum(value, type) {
+        this.appendValue(value, type);
+    }
+    appendList(value, type) {
+        this.appendValue(value instanceof values_1.DuckDBListValue ? value : (0, values_1.listValue)(value), type);
+    }
+    appendStruct(value, type) {
+        this.appendValue(value instanceof values_1.DuckDBStructValue ? value : (0, values_1.structValue)(value), type);
+    }
+    appendMap(value, type) {
+        this.appendValue(value, type);
+    }
+    appendArray(value, type) {
+        this.appendValue(value instanceof values_1.DuckDBArrayValue ? value : (0, values_1.arrayValue)(value), type);
+    }
+    appendUnion(value, type) {
+        this.appendValue(value, type);
+    }
+    appendUUID(value) {
+        this.appendValue(value, DuckDBType_1.UUID);
+    }
+    appendBit(value) {
+        this.appendValue(value, DuckDBType_1.BIT);
+    }
+    appendBigNum(value) {
+        this.appendValue(value, DuckDBType_1.BIGNUM);
+    }
+    appendNull() {
+        node_bindings_1.default.append_null(this.appender);
+    }
+    appendValue(value, type) {
+        node_bindings_1.default.append_value(this.appender, (0, createValue_1.createValue)(type ? type : (0, typeForValue_1.typeForValue)(value), value));
+    }
+    appendDataChunk(dataChunk) {
+        node_bindings_1.default.append_data_chunk(this.appender, dataChunk.chunk);
+    }
+}
+exports.DuckDBAppender = DuckDBAppender;

package/lib/DuckDBBindInfo.d.ts

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

package/lib/DuckDBBindInfo.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBBindInfo = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBClientContext_1 = require("./DuckDBClientContext");
+class DuckDBBindInfo {
+    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.scalar_function_get_client_context(this.bind_info));
+    }
+    get extraInfo() {
+        return this.getExtraInfo();
+    }
+    getExtraInfo() {
+        return node_bindings_1.default.scalar_function_bind_get_extra_info(this.bind_info);
+    }
+    setBindData(bindData) {
+        node_bindings_1.default.scalar_function_set_bind_data(this.bind_info, bindData);
+    }
+    setError(error) {
+        node_bindings_1.default.scalar_function_bind_set_error(this.bind_info, error);
+    }
+}
+exports.DuckDBBindInfo = DuckDBBindInfo;

package/lib/DuckDBClientContext.d.ts

@@ -0,0 +1,6 @@
+import duckdb from '@haybarn/node-bindings';
+export declare class DuckDBClientContext {
+    private readonly client_context;
+    constructor(client_context: duckdb.ClientContext);
+    get connectionId(): number;
+}

package/lib/DuckDBClientContext.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBClientContext = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+class DuckDBClientContext {
+    client_context;
+    constructor(client_context) {
+        this.client_context = client_context;
+    }
+    get connectionId() {
+        return node_bindings_1.default.client_context_get_connection_id(this.client_context);
+    }
+}
+exports.DuckDBClientContext = DuckDBClientContext;

package/lib/DuckDBConnection.d.ts

@@ -0,0 +1,49 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBAppender } from './DuckDBAppender';
+import { DuckDBClientContext } from './DuckDBClientContext';
+import { DuckDBExtractedStatements } from './DuckDBExtractedStatements';
+import { DuckDBInstance } from './DuckDBInstance';
+import { DuckDBMaterializedResult } from './DuckDBMaterializedResult';
+import { DuckDBPendingResult } from './DuckDBPendingResult';
+import { DuckDBPreparedStatement } from './DuckDBPreparedStatement';
+import { DuckDBResult } from './DuckDBResult';
+import { DuckDBResultReader } from './DuckDBResultReader';
+import { DuckDBScalarFunction } from './DuckDBScalarFunction';
+import { DuckDBType } from './DuckDBType';
+import { DuckDBValue } from './values';
+export declare class DuckDBConnection {
+    private readonly connection;
+    private readonly preparedStatements;
+    constructor(connection: duckdb.Connection);
+    static create(instance?: DuckDBInstance): Promise<DuckDBConnection>;
+    /** Same as disconnectSync. */
+    closeSync(): void;
+    disconnectSync(): void;
+    get clientContext(): DuckDBClientContext;
+    getClientContext(): DuckDBClientContext;
+    interrupt(): void;
+    get progress(): duckdb.QueryProgress;
+    run(sql: string, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBMaterializedResult>;
+    runAndRead(sql: string, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBResultReader>;
+    runAndReadAll(sql: string, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBResultReader>;
+    runAndReadUntil(sql: string, targetRowCount: number, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBResultReader>;
+    stream(sql: string, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBResult>;
+    streamAndRead(sql: string, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBResultReader>;
+    streamAndReadAll(sql: string, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBResultReader>;
+    streamAndReadUntil(sql: string, targetRowCount: number, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBResultReader>;
+    start(sql: string, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBPendingResult>;
+    startThenRead(sql: string, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBResultReader>;
+    startThenReadAll(sql: string, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBResultReader>;
+    startThenReadUntil(sql: string, targetRowCount: number, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBResultReader>;
+    startStream(sql: string, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBPendingResult>;
+    startStreamThenRead(sql: string, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBResultReader>;
+    startStreamThenReadAll(sql: string, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBResultReader>;
+    startStreamThenReadUntil(sql: string, targetRowCount: number, values?: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): Promise<DuckDBResultReader>;
+    prepare(sql: string): Promise<DuckDBPreparedStatement>;
+    private createPrepared;
+    extractStatements(sql: string): Promise<DuckDBExtractedStatements>;
+    private runUntilLast;
+    getTableNames(query: string, qualified: boolean): readonly string[];
+    createAppender(table: string, schema?: string | null, catalog?: string | null): Promise<DuckDBAppender>;
+    registerScalarFunction(scalarFunction: DuckDBScalarFunction): void;
+}

package/lib/DuckDBConnection.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBConnection = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBAppender_1 = require("./DuckDBAppender");
+const DuckDBClientContext_1 = require("./DuckDBClientContext");
+const DuckDBExtractedStatements_1 = require("./DuckDBExtractedStatements");
+const DuckDBInstance_1 = require("./DuckDBInstance");
+const DuckDBMaterializedResult_1 = require("./DuckDBMaterializedResult");
+const DuckDBPreparedStatement_1 = require("./DuckDBPreparedStatement");
+const DuckDBPreparedStatementWeakRefCollection_1 = require("./DuckDBPreparedStatementWeakRefCollection");
+const DuckDBResultReader_1 = require("./DuckDBResultReader");
+class DuckDBConnection {
+    connection;
+    preparedStatements;
+    constructor(connection) {
+        this.connection = connection;
+        this.preparedStatements = new DuckDBPreparedStatementWeakRefCollection_1.DuckDBPreparedStatementWeakRefCollection();
+    }
+    static async create(instance) {
+        if (instance) {
+            return instance.connect();
+        }
+        return (await DuckDBInstance_1.DuckDBInstance.fromCache()).connect();
+    }
+    /** Same as disconnectSync. */
+    closeSync() {
+        this.disconnectSync();
+    }
+    disconnectSync() {
+        this.preparedStatements.destroySync();
+        node_bindings_1.default.disconnect_sync(this.connection);
+    }
+    get clientContext() {
+        return this.getClientContext();
+    }
+    getClientContext() {
+        return new DuckDBClientContext_1.DuckDBClientContext(node_bindings_1.default.connection_get_client_context(this.connection));
+    }
+    interrupt() {
+        node_bindings_1.default.interrupt(this.connection);
+    }
+    get progress() {
+        return node_bindings_1.default.query_progress(this.connection);
+    }
+    async run(sql, values, types) {
+        if (values) {
+            const prepared = await this.runUntilLast(sql);
+            try {
+                prepared.bind(values, types);
+                const result = await prepared.run();
+                return result;
+            }
+            finally {
+                prepared.destroySync();
+            }
+        }
+        else {
+            return new DuckDBMaterializedResult_1.DuckDBMaterializedResult(await node_bindings_1.default.query(this.connection, sql));
+        }
+    }
+    async runAndRead(sql, values, types) {
+        return new DuckDBResultReader_1.DuckDBResultReader(await this.run(sql, values, types));
+    }
+    async runAndReadAll(sql, values, types) {
+        const reader = await this.runAndRead(sql, values, types);
+        await reader.readAll();
+        return reader;
+    }
+    async runAndReadUntil(sql, targetRowCount, values, types) {
+        const reader = await this.runAndRead(sql, values, types);
+        await reader.readUntil(targetRowCount);
+        return reader;
+    }
+    async stream(sql, values, types) {
+        const prepared = await this.runUntilLast(sql);
+        try {
+            if (values) {
+                prepared.bind(values, types);
+            }
+            const result = await prepared.stream();
+            return result;
+        }
+        finally {
+            prepared.destroySync();
+        }
+    }
+    async streamAndRead(sql, values, types) {
+        return new DuckDBResultReader_1.DuckDBResultReader(await this.stream(sql, values, types));
+    }
+    async streamAndReadAll(sql, values, types) {
+        const reader = await this.streamAndRead(sql, values, types);
+        await reader.readAll();
+        return reader;
+    }
+    async streamAndReadUntil(sql, targetRowCount, values, types) {
+        const reader = await this.streamAndRead(sql, values, types);
+        await reader.readUntil(targetRowCount);
+        return reader;
+    }
+    async start(sql, values, types) {
+        const prepared = await this.runUntilLast(sql);
+        try {
+            if (values) {
+                prepared.bind(values, types);
+            }
+            return prepared.start();
+        }
+        finally {
+            prepared.destroySync();
+        }
+    }
+    async startThenRead(sql, values, types) {
+        const pending = await this.start(sql, values, types);
+        await pending.runAllTasks();
+        return new DuckDBResultReader_1.DuckDBResultReader(await pending.getResult());
+    }
+    async startThenReadAll(sql, values, types) {
+        const reader = await this.startThenRead(sql, values, types);
+        await reader.readAll();
+        return reader;
+    }
+    async startThenReadUntil(sql, targetRowCount, values, types) {
+        const reader = await this.startThenRead(sql, values, types);
+        await reader.readUntil(targetRowCount);
+        return reader;
+    }
+    async startStream(sql, values, types) {
+        const prepared = await this.runUntilLast(sql);
+        try {
+            if (values) {
+                prepared.bind(values, types);
+            }
+            return prepared.startStream();
+        }
+        finally {
+            prepared.destroySync();
+        }
+    }
+    async startStreamThenRead(sql, values, types) {
+        const pending = await this.startStream(sql, values, types);
+        await pending.runAllTasks();
+        return new DuckDBResultReader_1.DuckDBResultReader(await pending.getResult());
+    }
+    async startStreamThenReadAll(sql, values, types) {
+        const reader = await this.startStreamThenRead(sql, values, types);
+        await reader.readAll();
+        return reader;
+    }
+    async startStreamThenReadUntil(sql, targetRowCount, values, types) {
+        const reader = await this.startStreamThenRead(sql, values, types);
+        await reader.readUntil(targetRowCount);
+        return reader;
+    }
+    async prepare(sql) {
+        const prepared = await this.createPrepared(sql);
+        this.preparedStatements.add(prepared);
+        return prepared;
+    }
+    async createPrepared(sql) {
+        return new DuckDBPreparedStatement_1.DuckDBPreparedStatement(await node_bindings_1.default.prepare(this.connection, sql));
+    }
+    async extractStatements(sql) {
+        const { extracted_statements, statement_count } = await node_bindings_1.default.extract_statements(this.connection, sql);
+        if (statement_count === 0) {
+            throw new Error(`Failed to extract statements: ${node_bindings_1.default.extract_statements_error(extracted_statements)}`);
+        }
+        return new DuckDBExtractedStatements_1.DuckDBExtractedStatements(this.connection, extracted_statements, statement_count, this.preparedStatements);
+    }
+    async runUntilLast(sql) {
+        const extractedStatements = await this.extractStatements(sql);
+        const statementCount = extractedStatements.count;
+        if (statementCount > 1) {
+            for (let i = 0; i < statementCount - 1; i++) {
+                const prepared = await extractedStatements.prepare(i);
+                try {
+                    await prepared.run();
+                }
+                finally {
+                    prepared.destroySync();
+                }
+            }
+        }
+        return extractedStatements.prepare(statementCount - 1);
+    }
+    getTableNames(query, qualified) {
+        const names = [];
+        const list_value = node_bindings_1.default.get_table_names(this.connection, query, qualified);
+        const count = node_bindings_1.default.get_list_size(list_value);
+        for (let i = 0; i < count; i++) {
+            const varchar_value = node_bindings_1.default.get_list_child(list_value, i);
+            const name = node_bindings_1.default.get_varchar(varchar_value);
+            names.push(name);
+        }
+        names.sort();
+        return names;
+    }
+    async createAppender(table, schema, catalog) {
+        return new DuckDBAppender_1.DuckDBAppender(node_bindings_1.default.appender_create_ext(this.connection, catalog ?? null, schema ?? null, table));
+    }
+    registerScalarFunction(scalarFunction) {
+        node_bindings_1.default.register_scalar_function(this.connection, scalarFunction.scalar_function);
+    }
+}
+exports.DuckDBConnection = DuckDBConnection;

package/lib/DuckDBDataChunk.d.ts

@@ -0,0 +1,41 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBType } from './DuckDBType';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValue } from './values';
+export declare class DuckDBDataChunk {
+    readonly chunk: duckdb.DataChunk;
+    private readonly vectors;
+    constructor(chunk: duckdb.DataChunk);
+    static create(types: readonly DuckDBType[], rowCount?: number): DuckDBDataChunk;
+    reset(): void;
+    get columnCount(): number;
+    get rowCount(): number;
+    set rowCount(count: number);
+    getColumnVector(columnIndex: number): DuckDBVector;
+    visitColumnValues(columnIndex: number, visitValue: (value: DuckDBValue, rowIndex: number, columnIndex: number, type: DuckDBType) => void): void;
+    appendColumnValues(columnIndex: number, values: DuckDBValue[]): void;
+    getColumnValues(columnIndex: number): DuckDBValue[];
+    convertColumnValues<T>(columnIndex: number, converter: DuckDBValueConverter<T>): (T | null)[];
+    setColumnValues(columnIndex: number, values: readonly DuckDBValue[]): void;
+    visitColumns(visitColumn: (column: DuckDBValue[], columnIndex: number, type: DuckDBType) => void): void;
+    appendToColumns(columns: (DuckDBValue[] | undefined)[]): void;
+    getColumns(): DuckDBValue[][];
+    convertColumns<T>(converter: DuckDBValueConverter<T>): (T | null)[][];
+    setColumns(columns: readonly (readonly DuckDBValue[])[]): void;
+    appendToColumnsObject(columnNames: readonly string[], columnsObject: Record<string, DuckDBValue[] | undefined>): void;
+    getColumnsObject(columnNames: readonly string[]): Record<string, DuckDBValue[]>;
+    visitColumnMajor(visitValue: (value: DuckDBValue, rowIndex: number, columnIndex: number, type: DuckDBType) => void): void;
+    visitRowValues(rowIndex: number, visitValue: (value: DuckDBValue, rowIndex: number, columnIndex: number, type: DuckDBType) => void): void;
+    appendRowValues(rowIndex: number, values: DuckDBValue[]): void;
+    getRowValues(rowIndex: number): DuckDBValue[];
+    convertRowValues<T>(rowIndex: number, converter: DuckDBValueConverter<T>): (T | null)[];
+    visitRows(visitRow: (row: DuckDBValue[], rowIndex: number) => void): void;
+    appendToRows(rows: DuckDBValue[][]): void;
+    getRows(): DuckDBValue[][];
+    convertRows<T>(converter: DuckDBValueConverter<T>): (T | null)[][];
+    setRows(rows: readonly (readonly DuckDBValue[])[]): void;
+    appendToRowObjects(columnNames: readonly string[], rowObjects: Record<string, DuckDBValue>[]): void;
+    getRowObjects(columnNames: readonly string[]): Record<string, DuckDBValue>[];
+    visitRowMajor(visitValue: (value: DuckDBValue, rowIndex: number, columnIndex: number, type: DuckDBType) => void): void;
+}