@duckdb/node-api 1.1.2-alpha.1

package/lib/DuckDBLogicalType.js

@@ -0,0 +1,292 @@
+"use strict";
+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;
+const node_bindings_1 = __importDefault(require("@duckdb/node-bindings"));
+const DuckDBType_1 = require("./DuckDBType");
+const DuckDBTypeId_1 = require("./DuckDBTypeId");
+class DuckDBLogicalType {
+    logical_type;
+    constructor(logical_type) {
+        this.logical_type = logical_type;
+    }
+    static consumeAsType(logical_type) {
+        const logicalType = DuckDBLogicalType.create(logical_type);
+        const type = logicalType.asType();
+        logicalType.dispose();
+        return type;
+    }
+    static create(logical_type) {
+        switch (node_bindings_1.default.get_type_id(logical_type)) {
+            case node_bindings_1.default.Type.DECIMAL:
+                return new DuckDBDecimalLogicalType(logical_type);
+            case node_bindings_1.default.Type.ENUM:
+                return new DuckDBEnumLogicalType(logical_type);
+            case node_bindings_1.default.Type.LIST:
+                return new DuckDBListLogicalType(logical_type);
+            case node_bindings_1.default.Type.STRUCT:
+                return new DuckDBStructLogicalType(logical_type);
+            case node_bindings_1.default.Type.MAP:
+                return new DuckDBMapLogicalType(logical_type);
+            case node_bindings_1.default.Type.ARRAY:
+                return new DuckDBArrayLogicalType(logical_type);
+            case node_bindings_1.default.Type.UNION:
+                return new DuckDBUnionLogicalType(logical_type);
+            default:
+                return new DuckDBLogicalType(logical_type);
+        }
+    }
+    static createDecimal(width, scale) {
+        return new DuckDBDecimalLogicalType(node_bindings_1.default.create_decimal_type(width, scale));
+    }
+    static createEnum(member_names) {
+        return new DuckDBEnumLogicalType(node_bindings_1.default.create_enum_type(member_names));
+    }
+    static createList(valueType) {
+        return new DuckDBListLogicalType(node_bindings_1.default.create_list_type(valueType.logical_type));
+    }
+    static createStruct(entries) {
+        const member_types = [];
+        const member_names = [];
+        for (const entry of entries) {
+            member_types.push(entry.valueType.logical_type);
+            member_names.push(entry.name);
+        }
+        return new DuckDBStructLogicalType(node_bindings_1.default.create_struct_type(member_types, member_names));
+    }
+    static createMap(keyType, valueType) {
+        return new DuckDBMapLogicalType(node_bindings_1.default.create_map_type(keyType.logical_type, valueType.logical_type));
+    }
+    static createArray(valueType, length) {
+        return new DuckDBArrayLogicalType(node_bindings_1.default.create_array_type(valueType.logical_type, length));
+    }
+    static createUnion(alternatives) {
+        const member_types = [];
+        const member_names = [];
+        for (const alternative of alternatives) {
+            member_types.push(alternative.valueType.logical_type);
+            member_names.push(alternative.tag);
+        }
+        return new DuckDBUnionLogicalType(node_bindings_1.default.create_union_type(member_types, member_names));
+    }
+    dispose() {
+        node_bindings_1.default.destroy_logical_type(this.logical_type);
+    }
+    get typeId() {
+        return node_bindings_1.default.get_type_id(this.logical_type);
+    }
+    get alias() {
+        return node_bindings_1.default.logical_type_get_alias(this.logical_type);
+    }
+    set alias(newAlias) {
+        node_bindings_1.default.logical_type_set_alias(this.logical_type, newAlias);
+    }
+    asType() {
+        switch (this.typeId) {
+            case DuckDBTypeId_1.DuckDBTypeId.BOOLEAN:
+                return DuckDBType_1.DuckDBBooleanType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.TINYINT:
+                return DuckDBType_1.DuckDBTinyIntType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.SMALLINT:
+                return DuckDBType_1.DuckDBSmallIntType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.INTEGER:
+                return DuckDBType_1.DuckDBIntegerType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.BIGINT:
+                return DuckDBType_1.DuckDBBigIntType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.UTINYINT:
+                return DuckDBType_1.DuckDBUTinyIntType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.USMALLINT:
+                return DuckDBType_1.DuckDBUSmallIntType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.UINTEGER:
+                return DuckDBType_1.DuckDBUIntegerType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.UBIGINT:
+                return DuckDBType_1.DuckDBUBigIntType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.FLOAT:
+                return DuckDBType_1.DuckDBFloatType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.DOUBLE:
+                return DuckDBType_1.DuckDBDoubleType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP:
+                return DuckDBType_1.DuckDBTimestampType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.DATE:
+                return DuckDBType_1.DuckDBDateType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.TIME:
+                return DuckDBType_1.DuckDBTimeType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.INTERVAL:
+                return DuckDBType_1.DuckDBIntervalType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.HUGEINT:
+                return DuckDBType_1.DuckDBHugeIntType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.UHUGEINT:
+                return DuckDBType_1.DuckDBUHugeIntType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.VARCHAR:
+                return DuckDBType_1.DuckDBVarCharType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.BLOB:
+                return DuckDBType_1.DuckDBBlobType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.DECIMAL:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_S:
+                return DuckDBType_1.DuckDBTimestampSecondsType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_MS:
+                return DuckDBType_1.DuckDBTimestampMillisecondsType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_NS:
+                return DuckDBType_1.DuckDBTimestampNanosecondsType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.ENUM:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.LIST:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.STRUCT:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.MAP:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.ARRAY:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.UUID:
+                return DuckDBType_1.DuckDBUUIDType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.UNION:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.BIT:
+                return DuckDBType_1.DuckDBBitType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.TIME_TZ:
+                return DuckDBType_1.DuckDBTimeTZType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_TZ:
+                return DuckDBType_1.DuckDBTimestampTZType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.ANY:
+                return DuckDBType_1.DuckDBAnyType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.VARINT:
+                return DuckDBType_1.DuckDBVarIntType.instance;
+            case DuckDBTypeId_1.DuckDBTypeId.SQLNULL:
+                return DuckDBType_1.DuckDBSQLNullType.instance;
+            default:
+                throw new Error(`Unexpected type id: ${this.typeId}`);
+        }
+    }
+}
+exports.DuckDBLogicalType = DuckDBLogicalType;
+class DuckDBDecimalLogicalType extends DuckDBLogicalType {
+    get width() {
+        return node_bindings_1.default.decimal_width(this.logical_type);
+    }
+    get scale() {
+        return node_bindings_1.default.decimal_scale(this.logical_type);
+    }
+    get internalTypeId() {
+        return node_bindings_1.default.decimal_internal_type(this.logical_type);
+    }
+    asType() {
+        return new DuckDBType_1.DuckDBDecimalType(this.width, this.scale);
+    }
+}
+exports.DuckDBDecimalLogicalType = DuckDBDecimalLogicalType;
+class DuckDBEnumLogicalType extends DuckDBLogicalType {
+    get valueCount() {
+        return node_bindings_1.default.enum_dictionary_size(this.logical_type);
+    }
+    value(index) {
+        return node_bindings_1.default.enum_dictionary_value(this.logical_type, index);
+    }
+    values() {
+        const values = [];
+        const count = this.valueCount;
+        for (let i = 0; i < count; i++) {
+            values.push(this.value(i));
+        }
+        return values;
+    }
+    get internalTypeId() {
+        return node_bindings_1.default.enum_internal_type(this.logical_type);
+    }
+    asType() {
+        return new DuckDBType_1.DuckDBEnumType(this.values(), this.internalTypeId);
+    }
+}
+exports.DuckDBEnumLogicalType = DuckDBEnumLogicalType;
+class DuckDBListLogicalType extends DuckDBLogicalType {
+    get valueType() {
+        return DuckDBLogicalType.create(node_bindings_1.default.list_type_child_type(this.logical_type));
+    }
+    asType() {
+        return new DuckDBType_1.DuckDBListType(this.valueType.asType());
+    }
+}
+exports.DuckDBListLogicalType = DuckDBListLogicalType;
+class DuckDBStructLogicalType extends DuckDBLogicalType {
+    get entryCount() {
+        return node_bindings_1.default.struct_type_child_count(this.logical_type);
+    }
+    entryName(index) {
+        return node_bindings_1.default.struct_type_child_name(this.logical_type, index);
+    }
+    entryValueType(index) {
+        return DuckDBLogicalType.create(node_bindings_1.default.struct_type_child_type(this.logical_type, index));
+    }
+    entries() {
+        const entries = [];
+        const count = this.entryCount;
+        for (let i = 0; i < count; i++) {
+            const name = this.entryName(i);
+            const valueType = this.entryValueType(i);
+            entries.push({ name, valueType });
+        }
+        return entries;
+    }
+    asType() {
+        return new DuckDBType_1.DuckDBStructType(this.entries().map(({ name, valueType }) => ({
+            name,
+            valueType: valueType.asType(),
+        })));
+    }
+}
+exports.DuckDBStructLogicalType = DuckDBStructLogicalType;
+class DuckDBMapLogicalType extends DuckDBLogicalType {
+    get keyType() {
+        return DuckDBLogicalType.create(node_bindings_1.default.map_type_key_type(this.logical_type));
+    }
+    get valueType() {
+        return DuckDBLogicalType.create(node_bindings_1.default.map_type_value_type(this.logical_type));
+    }
+    asType() {
+        return new DuckDBType_1.DuckDBMapType(this.keyType.asType(), this.valueType.asType());
+    }
+}
+exports.DuckDBMapLogicalType = DuckDBMapLogicalType;
+class DuckDBArrayLogicalType extends DuckDBLogicalType {
+    get valueType() {
+        return DuckDBLogicalType.create(node_bindings_1.default.array_type_child_type(this.logical_type));
+    }
+    get length() {
+        return node_bindings_1.default.array_type_array_size(this.logical_type);
+    }
+    asType() {
+        return new DuckDBType_1.DuckDBArrayType(this.valueType.asType(), this.length);
+    }
+}
+exports.DuckDBArrayLogicalType = DuckDBArrayLogicalType;
+class DuckDBUnionLogicalType extends DuckDBLogicalType {
+    get alternativeCount() {
+        return node_bindings_1.default.union_type_member_count(this.logical_type);
+    }
+    alternativeTag(index) {
+        return node_bindings_1.default.union_type_member_name(this.logical_type, index);
+    }
+    alternativeValueType(index) {
+        return DuckDBLogicalType.create(node_bindings_1.default.union_type_member_type(this.logical_type, index));
+    }
+    alternatives() {
+        const alternatives = [];
+        const count = this.alternativeCount;
+        for (let i = 0; i < count; i++) {
+            const tag = this.alternativeTag(i);
+            const valueType = this.alternativeValueType(i);
+            alternatives.push({ tag, valueType });
+        }
+        return alternatives;
+    }
+    asType() {
+        return new DuckDBType_1.DuckDBUnionType(this.alternatives().map(({ tag, valueType }) => ({
+            tag,
+            valueType: valueType.asType(),
+        })));
+    }
+}
+exports.DuckDBUnionLogicalType = DuckDBUnionLogicalType;

package/lib/DuckDBPendingResult.d.ts

@@ -0,0 +1,14 @@
+import duckdb from '@duckdb/node-bindings';
+import { DuckDBResult } from './DuckDBResult';
+export declare enum DuckDBPendingResultState {
+    RESULT_READY = 0,
+    RESULT_NOT_READY = 1,
+    NO_TASKS_AVAILABLE = 3
+}
+export declare class DuckDBPendingResult {
+    private readonly pending_result;
+    constructor(pending_result: duckdb.PendingResult);
+    dispose(): void;
+    runTask(): DuckDBPendingResultState;
+    getResult(): Promise<DuckDBResult>;
+}

package/lib/DuckDBPendingResult.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBPendingResult = exports.DuckDBPendingResultState = void 0;
+const node_bindings_1 = __importDefault(require("@duckdb/node-bindings"));
+const DuckDBResult_1 = require("./DuckDBResult");
+// Values match similar enum in C API.
+var DuckDBPendingResultState;
+(function (DuckDBPendingResultState) {
+    DuckDBPendingResultState[DuckDBPendingResultState["RESULT_READY"] = 0] = "RESULT_READY";
+    DuckDBPendingResultState[DuckDBPendingResultState["RESULT_NOT_READY"] = 1] = "RESULT_NOT_READY";
+    DuckDBPendingResultState[DuckDBPendingResultState["NO_TASKS_AVAILABLE"] = 3] = "NO_TASKS_AVAILABLE";
+})(DuckDBPendingResultState || (exports.DuckDBPendingResultState = DuckDBPendingResultState = {}));
+class DuckDBPendingResult {
+    pending_result;
+    constructor(pending_result) {
+        this.pending_result = pending_result;
+    }
+    dispose() {
+        node_bindings_1.default.destroy_pending(this.pending_result);
+    }
+    runTask() {
+        const pending_state = node_bindings_1.default.pending_execute_task(this.pending_result);
+        switch (pending_state) {
+            case node_bindings_1.default.PendingState.RESULT_READY:
+                return DuckDBPendingResultState.RESULT_READY;
+            case node_bindings_1.default.PendingState.RESULT_NOT_READY:
+                return DuckDBPendingResultState.RESULT_NOT_READY;
+            case node_bindings_1.default.PendingState.ERROR:
+                throw new Error(`Failure running pending result task: ${node_bindings_1.default.pending_error(this.pending_result)}`);
+            case node_bindings_1.default.PendingState.NO_TASKS_AVAILABLE:
+                return DuckDBPendingResultState.NO_TASKS_AVAILABLE;
+            default:
+                throw new Error(`Unexpected pending state: ${pending_state}`);
+        }
+    }
+    async getResult() {
+        return new DuckDBResult_1.DuckDBResult(await node_bindings_1.default.execute_pending(this.pending_result));
+    }
+}
+exports.DuckDBPendingResult = DuckDBPendingResult;

package/lib/DuckDBPreparedStatement.d.ts

@@ -0,0 +1,40 @@
+import duckdb from '@duckdb/node-bindings';
+import { DuckDBPendingResult } from './DuckDBPendingResult';
+import { DuckDBResult } from './DuckDBResult';
+import { DuckDBTypeId } from './DuckDBTypeId';
+import { Date_, Decimal, Interval, Time, Timestamp } from './DuckDBValue';
+import { StatementType } from './enums';
+export declare class DuckDBPreparedStatement {
+    private readonly prepared_statement;
+    constructor(prepared_statement: duckdb.PreparedStatement);
+    dispose(): void;
+    get statementType(): StatementType;
+    get parameterCount(): number;
+    parameterName(parameterIndex: number): string;
+    parameterTypeId(parameterIndex: number): DuckDBTypeId;
+    clearBindings(): void;
+    parameterIndex(parameterName: string): number;
+    bindBoolean(parameterIndex: number, value: boolean): void;
+    bindTinyInt(parameterIndex: number, value: number): void;
+    bindSmallInt(parameterIndex: number, value: number): void;
+    bindInteger(parameterIndex: number, value: number): void;
+    bindBigInt(parameterIndex: number, value: bigint): void;
+    bindHugeInt(parameterIndex: number, value: bigint): void;
+    bindUTinyInt(parameterIndex: number, value: number): void;
+    bindUSmallInt(parameterIndex: number, value: number): void;
+    bindUInteger(parameterIndex: number, value: number): void;
+    bindUBigInt(parameterIndex: number, value: bigint): void;
+    bindUHugeInt(parameterIndex: number, value: bigint): void;
+    bindDecimal(parameterIndex: number, value: Decimal): void;
+    bindFloat(parameterIndex: number, value: number): void;
+    bindDouble(parameterIndex: number, value: number): void;
+    bindDate(parameterIndex: number, value: Date_): void;
+    bindTime(parameterIndex: number, value: Time): void;
+    bindTimestamp(parameterIndex: number, value: Timestamp): void;
+    bindInterval(parameterIndex: number, value: Interval): void;
+    bindVarchar(parameterIndex: number, value: string): void;
+    bindBlob(parameterIndex: number, value: Uint8Array): void;
+    bindNull(parameterIndex: number): void;
+    run(): Promise<DuckDBResult>;
+    start(): DuckDBPendingResult;
+}

package/lib/DuckDBPreparedStatement.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBPreparedStatement = void 0;
+const node_bindings_1 = __importDefault(require("@duckdb/node-bindings"));
+const DuckDBPendingResult_1 = require("./DuckDBPendingResult");
+const DuckDBResult_1 = require("./DuckDBResult");
+class DuckDBPreparedStatement {
+    prepared_statement;
+    constructor(prepared_statement) {
+        this.prepared_statement = prepared_statement;
+    }
+    dispose() {
+        node_bindings_1.default.destroy_prepare(this.prepared_statement);
+    }
+    get statementType() {
+        return node_bindings_1.default.prepared_statement_type(this.prepared_statement);
+    }
+    get parameterCount() {
+        return node_bindings_1.default.nparams(this.prepared_statement);
+    }
+    parameterName(parameterIndex) {
+        return node_bindings_1.default.parameter_name(this.prepared_statement, parameterIndex);
+    }
+    parameterTypeId(parameterIndex) {
+        return node_bindings_1.default.param_type(this.prepared_statement, parameterIndex);
+    }
+    clearBindings() {
+        node_bindings_1.default.clear_bindings(this.prepared_statement);
+    }
+    parameterIndex(parameterName) {
+        return node_bindings_1.default.bind_parameter_index(this.prepared_statement, parameterName);
+    }
+    bindBoolean(parameterIndex, value) {
+        node_bindings_1.default.bind_boolean(this.prepared_statement, parameterIndex, value);
+    }
+    bindTinyInt(parameterIndex, value) {
+        node_bindings_1.default.bind_int8(this.prepared_statement, parameterIndex, value);
+    }
+    bindSmallInt(parameterIndex, value) {
+        node_bindings_1.default.bind_int16(this.prepared_statement, parameterIndex, value);
+    }
+    bindInteger(parameterIndex, value) {
+        node_bindings_1.default.bind_int32(this.prepared_statement, parameterIndex, value);
+    }
+    bindBigInt(parameterIndex, value) {
+        node_bindings_1.default.bind_int64(this.prepared_statement, parameterIndex, value);
+    }
+    bindHugeInt(parameterIndex, value) {
+        node_bindings_1.default.bind_hugeint(this.prepared_statement, parameterIndex, value);
+    }
+    bindUTinyInt(parameterIndex, value) {
+        node_bindings_1.default.bind_uint8(this.prepared_statement, parameterIndex, value);
+    }
+    bindUSmallInt(parameterIndex, value) {
+        node_bindings_1.default.bind_uint16(this.prepared_statement, parameterIndex, value);
+    }
+    bindUInteger(parameterIndex, value) {
+        node_bindings_1.default.bind_uint32(this.prepared_statement, parameterIndex, value);
+    }
+    bindUBigInt(parameterIndex, value) {
+        node_bindings_1.default.bind_uint64(this.prepared_statement, parameterIndex, value);
+    }
+    bindUHugeInt(parameterIndex, value) {
+        node_bindings_1.default.bind_uhugeint(this.prepared_statement, parameterIndex, value);
+    }
+    bindDecimal(parameterIndex, value) {
+        node_bindings_1.default.bind_decimal(this.prepared_statement, parameterIndex, value);
+    }
+    bindFloat(parameterIndex, value) {
+        node_bindings_1.default.bind_float(this.prepared_statement, parameterIndex, value);
+    }
+    bindDouble(parameterIndex, value) {
+        node_bindings_1.default.bind_double(this.prepared_statement, parameterIndex, value);
+    }
+    bindDate(parameterIndex, value) {
+        node_bindings_1.default.bind_date(this.prepared_statement, parameterIndex, value);
+    }
+    bindTime(parameterIndex, value) {
+        node_bindings_1.default.bind_time(this.prepared_statement, parameterIndex, value);
+    }
+    bindTimestamp(parameterIndex, value) {
+        node_bindings_1.default.bind_timestamp(this.prepared_statement, parameterIndex, value);
+    }
+    // TODO: bind TIMESTAMPS_S/_MS/_NS?
+    // TODO: bind TIME_TZ/TIMESTAMP_TZ?
+    bindInterval(parameterIndex, value) {
+        node_bindings_1.default.bind_interval(this.prepared_statement, parameterIndex, value);
+    }
+    bindVarchar(parameterIndex, value) {
+        node_bindings_1.default.bind_varchar(this.prepared_statement, parameterIndex, value);
+    }
+    bindBlob(parameterIndex, value) {
+        node_bindings_1.default.bind_blob(this.prepared_statement, parameterIndex, value);
+    }
+    // TODO: bind ENUM?
+    // TODO: bind nested types? (ARRAY, LIST, STRUCT, MAP, UNION) (using bindValue?)
+    // TODO: bind UUID?
+    // TODO: bind BIT?
+    bindNull(parameterIndex) {
+        node_bindings_1.default.bind_null(this.prepared_statement, parameterIndex);
+    }
+    // TODO: expose bindValue, or implement bindList, bindStruct, etc.?
+    // public bindValue(parameterIndex: number, value: Value) {
+    //   duckdb.bind_value(this.prepared_statement, parameterIndex, value);
+    // }
+    async run() {
+        return new DuckDBResult_1.DuckDBResult(await node_bindings_1.default.execute_prepared(this.prepared_statement));
+    }
+    start() {
+        return new DuckDBPendingResult_1.DuckDBPendingResult(node_bindings_1.default.pending_prepared(this.prepared_statement));
+    }
+}
+exports.DuckDBPreparedStatement = DuckDBPreparedStatement;

package/lib/DuckDBResult.d.ts

@@ -0,0 +1,20 @@
+import duckdb from '@duckdb/node-bindings';
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBLogicalType } from './DuckDBLogicalType';
+import { DuckDBType } from './DuckDBType';
+import { DuckDBTypeId } from './DuckDBTypeId';
+import { ResultReturnType, StatementType } from './enums';
+export declare class DuckDBResult {
+    private readonly result;
+    constructor(result: duckdb.Result);
+    dispose(): void;
+    get returnType(): ResultReturnType;
+    get statementType(): StatementType;
+    get columnCount(): number;
+    columnName(columnIndex: number): string;
+    columnTypeId(columnIndex: number): DuckDBTypeId;
+    columnLogicalType(columnIndex: number): DuckDBLogicalType;
+    columnType(columnIndex: number): DuckDBType;
+    get rowsChanged(): number;
+    fetchChunk(): Promise<DuckDBDataChunk>;
+}

package/lib/DuckDBResult.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBResult = void 0;
+const node_bindings_1 = __importDefault(require("@duckdb/node-bindings"));
+const DuckDBDataChunk_1 = require("./DuckDBDataChunk");
+const DuckDBLogicalType_1 = require("./DuckDBLogicalType");
+class DuckDBResult {
+    result;
+    constructor(result) {
+        this.result = result;
+    }
+    dispose() {
+        node_bindings_1.default.destroy_result(this.result);
+    }
+    get returnType() {
+        return node_bindings_1.default.result_return_type(this.result);
+    }
+    get statementType() {
+        return node_bindings_1.default.result_statement_type(this.result);
+    }
+    get columnCount() {
+        return node_bindings_1.default.column_count(this.result);
+    }
+    columnName(columnIndex) {
+        return node_bindings_1.default.column_name(this.result, columnIndex);
+    }
+    columnTypeId(columnIndex) {
+        return node_bindings_1.default.column_type(this.result, columnIndex);
+    }
+    columnLogicalType(columnIndex) {
+        return DuckDBLogicalType_1.DuckDBLogicalType.create(node_bindings_1.default.column_logical_type(this.result, columnIndex));
+    }
+    columnType(columnIndex) {
+        return DuckDBLogicalType_1.DuckDBLogicalType.consumeAsType(node_bindings_1.default.column_logical_type(this.result, columnIndex));
+    }
+    get rowsChanged() {
+        return node_bindings_1.default.rows_changed(this.result);
+    }
+    async fetchChunk() {
+        return new DuckDBDataChunk_1.DuckDBDataChunk(await node_bindings_1.default.fetch_chunk(this.result));
+    }
+}
+exports.DuckDBResult = DuckDBResult;