@haybarn/node-api 1.5.3-rc2

package/lib/DuckDBPreparedStatement.js

@@ -0,0 +1,219 @@
+"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("@haybarn/node-bindings"));
+const createValue_1 = require("./createValue");
+const DuckDBLogicalType_1 = require("./DuckDBLogicalType");
+const DuckDBMaterializedResult_1 = require("./DuckDBMaterializedResult");
+const DuckDBPendingResult_1 = require("./DuckDBPendingResult");
+const DuckDBResult_1 = require("./DuckDBResult");
+const DuckDBResultReader_1 = require("./DuckDBResultReader");
+const DuckDBType_1 = require("./DuckDBType");
+const typeForValue_1 = require("./typeForValue");
+const values_1 = require("./values");
+class DuckDBPreparedStatement {
+    prepared_statement;
+    constructor(prepared_statement) {
+        this.prepared_statement = prepared_statement;
+    }
+    destroySync() {
+        return node_bindings_1.default.destroy_prepare_sync(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);
+    }
+    parameterType(parameterIndex) {
+        return DuckDBLogicalType_1.DuckDBLogicalType.create(node_bindings_1.default.param_logical_type(this.prepared_statement, parameterIndex)).asType();
+    }
+    get columnCount() {
+        return node_bindings_1.default.prepared_statement_column_count(this.prepared_statement);
+    }
+    columnName(columnIndex) {
+        return node_bindings_1.default.prepared_statement_column_name(this.prepared_statement, columnIndex);
+    }
+    columnTypeId(columnIndex) {
+        return node_bindings_1.default.prepared_statement_column_type(this.prepared_statement, columnIndex);
+    }
+    columnType(columnIndex) {
+        return DuckDBLogicalType_1.DuckDBLogicalType.create(node_bindings_1.default.prepared_statement_column_logical_type(this.prepared_statement, columnIndex)).asType();
+    }
+    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);
+    }
+    bindBigNum(parameterIndex, value) {
+        this.bindValue(parameterIndex, value, DuckDBType_1.BIGNUM);
+    }
+    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);
+    }
+    bindTimeTZ(parameterIndex, value) {
+        this.bindValue(parameterIndex, value, DuckDBType_1.TIMETZ);
+    }
+    bindTimestamp(parameterIndex, value) {
+        node_bindings_1.default.bind_timestamp(this.prepared_statement, parameterIndex, value);
+    }
+    bindTimestampTZ(parameterIndex, value) {
+        this.bindValue(parameterIndex, value, DuckDBType_1.TIMESTAMPTZ);
+    }
+    bindTimestampSeconds(parameterIndex, value) {
+        this.bindValue(parameterIndex, value, DuckDBType_1.TIMESTAMP_S);
+    }
+    bindTimestampMilliseconds(parameterIndex, value) {
+        this.bindValue(parameterIndex, value, DuckDBType_1.TIMESTAMP_MS);
+    }
+    bindTimestampNanoseconds(parameterIndex, value) {
+        this.bindValue(parameterIndex, value, DuckDBType_1.TIMESTAMP_NS);
+    }
+    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);
+    }
+    bindEnum(parameterIndex, value, type) {
+        this.bindValue(parameterIndex, value, type);
+    }
+    bindArray(parameterIndex, value, type) {
+        this.bindValue(parameterIndex, value instanceof values_1.DuckDBArrayValue ? value : (0, values_1.arrayValue)(value), type);
+    }
+    bindList(parameterIndex, value, type) {
+        this.bindValue(parameterIndex, value instanceof values_1.DuckDBListValue ? value : (0, values_1.listValue)(value), type);
+    }
+    bindStruct(parameterIndex, value, type) {
+        this.bindValue(parameterIndex, value instanceof values_1.DuckDBStructValue ? value : (0, values_1.structValue)(value), type);
+    }
+    bindMap(parameterIndex, value, type) {
+        this.bindValue(parameterIndex, value, type);
+    }
+    bindUnion(parameterIndex, value, type) {
+        this.bindValue(parameterIndex, value, type);
+    }
+    bindUUID(parameterIndex, value) {
+        this.bindValue(parameterIndex, value, DuckDBType_1.UUID);
+    }
+    bindBit(parameterIndex, value) {
+        this.bindValue(parameterIndex, value, DuckDBType_1.BIT);
+    }
+    bindNull(parameterIndex) {
+        node_bindings_1.default.bind_null(this.prepared_statement, parameterIndex);
+    }
+    bindValue(parameterIndex, value, type) {
+        node_bindings_1.default.bind_value(this.prepared_statement, parameterIndex, (0, createValue_1.createValue)(type ? type : (0, typeForValue_1.typeForValue)(value), value));
+    }
+    bind(values, types) {
+        if (Array.isArray(values)) {
+            const typesIsArray = Array.isArray(types);
+            for (let i = 0; i < values.length; i++) {
+                this.bindValue(i + 1, values[i], typesIsArray ? types[i] : undefined);
+            }
+        }
+        else {
+            const typesIsRecord = types && !Array.isArray(types);
+            for (const key in values) {
+                this.bindValue(this.parameterIndex(key), values[key], typesIsRecord ? types[key] : undefined);
+            }
+        }
+    }
+    async run() {
+        return new DuckDBMaterializedResult_1.DuckDBMaterializedResult(await node_bindings_1.default.execute_prepared(this.prepared_statement));
+    }
+    async runAndRead() {
+        return new DuckDBResultReader_1.DuckDBResultReader(await this.run());
+    }
+    async runAndReadAll() {
+        const reader = new DuckDBResultReader_1.DuckDBResultReader(await this.run());
+        await reader.readAll();
+        return reader;
+    }
+    async runAndReadUntil(targetRowCount) {
+        const reader = new DuckDBResultReader_1.DuckDBResultReader(await this.run());
+        await reader.readUntil(targetRowCount);
+        return reader;
+    }
+    async stream() {
+        return new DuckDBResult_1.DuckDBResult(await node_bindings_1.default.execute_prepared_streaming(this.prepared_statement));
+    }
+    async streamAndRead() {
+        return new DuckDBResultReader_1.DuckDBResultReader(await this.stream());
+    }
+    async streamAndReadAll() {
+        const reader = new DuckDBResultReader_1.DuckDBResultReader(await this.stream());
+        await reader.readAll();
+        return reader;
+    }
+    async streamAndReadUntil(targetRowCount) {
+        const reader = new DuckDBResultReader_1.DuckDBResultReader(await this.stream());
+        await reader.readUntil(targetRowCount);
+        return reader;
+    }
+    start() {
+        return new DuckDBPendingResult_1.DuckDBPendingResult(node_bindings_1.default.pending_prepared(this.prepared_statement));
+    }
+    startStream() {
+        return new DuckDBPendingResult_1.DuckDBPendingResult(node_bindings_1.default.pending_prepared_streaming(this.prepared_statement));
+    }
+}
+exports.DuckDBPreparedStatement = DuckDBPreparedStatement;

package/lib/DuckDBPreparedStatementCollection.d.ts

@@ -0,0 +1,4 @@
+import { DuckDBPreparedStatement } from './DuckDBPreparedStatement';
+export interface DuckDBPreparedStatementCollection {
+    add(prepared: DuckDBPreparedStatement): void;
+}

package/lib/DuckDBPreparedStatementCollection.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/DuckDBPreparedStatementWeakRefCollection.d.ts

@@ -0,0 +1,9 @@
+import { DuckDBPreparedStatement } from './DuckDBPreparedStatement';
+import { DuckDBPreparedStatementCollection } from './DuckDBPreparedStatementCollection';
+export declare class DuckDBPreparedStatementWeakRefCollection implements DuckDBPreparedStatementCollection {
+    preparedStatements: WeakRef<DuckDBPreparedStatement>[];
+    lastPruneTime: number;
+    add(prepared: DuckDBPreparedStatement): void;
+    destroySync(): void;
+    private prune;
+}

package/lib/DuckDBPreparedStatementWeakRefCollection.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBPreparedStatementWeakRefCollection = void 0;
+class DuckDBPreparedStatementWeakRefCollection {
+    preparedStatements = [];
+    lastPruneTime = 0;
+    add(prepared) {
+        const now = performance.now();
+        if (now - this.lastPruneTime > 1000) {
+            this.lastPruneTime = now;
+            this.prune();
+        }
+        this.preparedStatements.push(new WeakRef(prepared));
+    }
+    destroySync() {
+        for (const preparedRef of this.preparedStatements) {
+            const prepared = preparedRef.deref();
+            if (prepared) {
+                prepared.destroySync();
+            }
+        }
+        this.preparedStatements = [];
+    }
+    prune() {
+        this.preparedStatements = this.preparedStatements.filter((ref) => !!ref.deref());
+    }
+}
+exports.DuckDBPreparedStatementWeakRefCollection = DuckDBPreparedStatementWeakRefCollection;

package/lib/DuckDBResult.d.ts

@@ -0,0 +1,57 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBLogicalType } from './DuckDBLogicalType';
+import { DuckDBType } from './DuckDBType';
+import { DuckDBTypeId } from './DuckDBTypeId';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+import { JS } from './JS';
+import { Json } from './Json';
+import { ResultReturnType, StatementType } from './enums';
+import { DuckDBValue } from './values';
+export declare class DuckDBResult {
+    protected readonly result: duckdb.Result;
+    constructor(result: duckdb.Result);
+    get returnType(): ResultReturnType;
+    get statementType(): StatementType;
+    get columnCount(): number;
+    columnName(columnIndex: number): string;
+    columnNames(): string[];
+    deduplicatedColumnNames(): string[];
+    columnTypeId(columnIndex: number): DuckDBTypeId;
+    columnLogicalType(columnIndex: number): DuckDBLogicalType;
+    columnType(columnIndex: number): DuckDBType;
+    columnTypeJson(columnIndex: number): Json;
+    columnTypes(): DuckDBType[];
+    columnTypesJson(): Json;
+    columnNamesAndTypesJson(): Json;
+    columnNameAndTypeObjectsJson(): Json;
+    get isStreaming(): boolean;
+    get rowsChanged(): number;
+    fetchChunk(): Promise<DuckDBDataChunk | null>;
+    fetchAllChunks(): Promise<DuckDBDataChunk[]>;
+    getColumns(): Promise<DuckDBValue[][]>;
+    convertColumns<T>(converter: DuckDBValueConverter<T>): Promise<(T | null)[][]>;
+    getColumnsJS(): Promise<JS[][]>;
+    getColumnsJson(): Promise<Json[][]>;
+    getColumnsObject(): Promise<Record<string, DuckDBValue[]>>;
+    convertColumnsObject<T>(converter: DuckDBValueConverter<T>): Promise<Record<string, (T | null)[]>>;
+    getColumnsObjectJS(): Promise<Record<string, JS[]>>;
+    getColumnsObjectJson(): Promise<Record<string, Json[]>>;
+    getRows(): Promise<DuckDBValue[][]>;
+    convertRows<T>(converter: DuckDBValueConverter<T>): Promise<(T | null)[][]>;
+    getRowsJS(): Promise<JS[][]>;
+    getRowsJson(): Promise<Json[][]>;
+    getRowObjects(): Promise<Record<string, DuckDBValue>[]>;
+    convertRowObjects<T>(converter: DuckDBValueConverter<T>): Promise<Record<string, T | null>[]>;
+    getRowObjectsJS(): Promise<Record<string, JS>[]>;
+    getRowObjectsJson(): Promise<Record<string, Json>[]>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<DuckDBDataChunk>;
+    yieldRows(): AsyncIterableIterator<DuckDBValue[][]>;
+    yieldRowObjects(): AsyncIterableIterator<Record<string, DuckDBValue>[]>;
+    yieldConvertedRows<T>(converter: DuckDBValueConverter<T>): AsyncIterableIterator<(T | null)[][]>;
+    yieldConvertedRowObjects<T>(converter: DuckDBValueConverter<T>): AsyncIterableIterator<Record<string, T | null>[]>;
+    yieldRowsJs(): AsyncIterableIterator<JS[][]>;
+    yieldRowsJson(): AsyncIterableIterator<Json[][]>;
+    yieldRowObjectJs(): AsyncIterableIterator<Record<string, JS>[]>;
+    yieldRowObjectJson(): AsyncIterableIterator<Record<string, Json>[]>;
+}

package/lib/DuckDBResult.js

@@ -0,0 +1,229 @@
+"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("@haybarn/node-bindings"));
+const DuckDBDataChunk_1 = require("./DuckDBDataChunk");
+const DuckDBLogicalType_1 = require("./DuckDBLogicalType");
+const JSDuckDBValueConverter_1 = require("./JSDuckDBValueConverter");
+const JsonDuckDBValueConverter_1 = require("./JsonDuckDBValueConverter");
+const convertColumnsFromChunks_1 = require("./convertColumnsFromChunks");
+const convertColumnsObjectFromChunks_1 = require("./convertColumnsObjectFromChunks");
+const convertRowObjectsFromChunks_1 = require("./convertRowObjectsFromChunks");
+const convertRowsFromChunks_1 = require("./convertRowsFromChunks");
+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) {
+        this.result = 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);
+    }
+    columnNames() {
+        const columnNames = [];
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            columnNames.push(this.columnName(columnIndex));
+        }
+        return columnNames;
+    }
+    deduplicatedColumnNames() {
+        const outputColumnNames = [];
+        const columnCount = this.columnCount;
+        const columnNameCount = {};
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            const inputColumnName = this.columnName(columnIndex);
+            const nameCount = (columnNameCount[inputColumnName] || 0) + 1;
+            columnNameCount[inputColumnName] = nameCount;
+            if (nameCount > 1) {
+                outputColumnNames.push(`${inputColumnName}:${nameCount - 1}`);
+            }
+            else {
+                outputColumnNames.push(inputColumnName);
+            }
+        }
+        return outputColumnNames;
+    }
+    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.create(node_bindings_1.default.column_logical_type(this.result, columnIndex)).asType();
+    }
+    columnTypeJson(columnIndex) {
+        return this.columnType(columnIndex).toJson();
+    }
+    columnTypes() {
+        const columnTypes = [];
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            columnTypes.push(this.columnType(columnIndex));
+        }
+        return columnTypes;
+    }
+    columnTypesJson() {
+        const columnTypesJson = [];
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            columnTypesJson.push(this.columnTypeJson(columnIndex));
+        }
+        return columnTypesJson;
+    }
+    columnNamesAndTypesJson() {
+        return {
+            columnNames: this.columnNames(),
+            columnTypes: this.columnTypesJson(),
+        };
+    }
+    columnNameAndTypeObjectsJson() {
+        const columnNameAndTypeObjects = [];
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            columnNameAndTypeObjects.push({
+                columnName: this.columnName(columnIndex),
+                columnType: this.columnTypeJson(columnIndex),
+            });
+        }
+        return columnNameAndTypeObjects;
+    }
+    get isStreaming() {
+        return node_bindings_1.default.result_is_streaming(this.result);
+    }
+    get rowsChanged() {
+        return node_bindings_1.default.rows_changed(this.result);
+    }
+    async fetchChunk() {
+        const chunk = await node_bindings_1.default.fetch_chunk(this.result);
+        return chunk ? new DuckDBDataChunk_1.DuckDBDataChunk(chunk) : null;
+    }
+    async fetchAllChunks() {
+        const chunks = [];
+        while (true) {
+            const chunk = await this.fetchChunk();
+            if (!chunk || chunk.rowCount === 0) {
+                return chunks;
+            }
+            chunks.push(chunk);
+        }
+    }
+    async getColumns() {
+        const chunks = await this.fetchAllChunks();
+        return (0, getColumnsFromChunks_1.getColumnsFromChunks)(chunks);
+    }
+    async convertColumns(converter) {
+        const chunks = await this.fetchAllChunks();
+        return (0, convertColumnsFromChunks_1.convertColumnsFromChunks)(chunks, converter);
+    }
+    async getColumnsJS() {
+        return this.convertColumns(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
+    }
+    async getColumnsJson() {
+        return this.convertColumns(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
+    }
+    async getColumnsObject() {
+        const chunks = await this.fetchAllChunks();
+        return (0, getColumnsObjectFromChunks_1.getColumnsObjectFromChunks)(chunks, this.deduplicatedColumnNames());
+    }
+    async convertColumnsObject(converter) {
+        const chunks = await this.fetchAllChunks();
+        return (0, convertColumnsObjectFromChunks_1.convertColumnsObjectFromChunks)(chunks, this.deduplicatedColumnNames(), converter);
+    }
+    async getColumnsObjectJS() {
+        return this.convertColumnsObject(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
+    }
+    async getColumnsObjectJson() {
+        return this.convertColumnsObject(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
+    }
+    async getRows() {
+        const chunks = await this.fetchAllChunks();
+        return (0, getRowsFromChunks_1.getRowsFromChunks)(chunks);
+    }
+    async convertRows(converter) {
+        const chunks = await this.fetchAllChunks();
+        return (0, convertRowsFromChunks_1.convertRowsFromChunks)(chunks, converter);
+    }
+    async getRowsJS() {
+        return this.convertRows(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
+    }
+    async getRowsJson() {
+        return this.convertRows(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
+    }
+    async getRowObjects() {
+        const chunks = await this.fetchAllChunks();
+        return (0, getRowObjectsFromChunks_1.getRowObjectsFromChunks)(chunks, this.deduplicatedColumnNames());
+    }
+    async convertRowObjects(converter) {
+        const chunks = await this.fetchAllChunks();
+        return (0, convertRowObjectsFromChunks_1.convertRowObjectsFromChunks)(chunks, this.deduplicatedColumnNames(), converter);
+    }
+    async getRowObjectsJS() {
+        return this.convertRowObjects(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
+    }
+    async getRowObjectsJson() {
+        return this.convertRowObjects(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            const chunk = await this.fetchChunk();
+            if (chunk && chunk.rowCount > 0) {
+                yield chunk;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    async *yieldRows() {
+        for await (const chunk of this) {
+            yield (0, getRowsFromChunks_1.getRowsFromChunks)([chunk]);
+        }
+    }
+    async *yieldRowObjects() {
+        const deduplicatedColumnNames = this.deduplicatedColumnNames();
+        for await (const chunk of this) {
+            yield (0, getRowObjectsFromChunks_1.getRowObjectsFromChunks)([chunk], deduplicatedColumnNames);
+        }
+    }
+    async *yieldConvertedRows(converter) {
+        for await (const chunk of this) {
+            yield (0, convertRowsFromChunks_1.convertRowsFromChunks)([chunk], converter);
+        }
+    }
+    async *yieldConvertedRowObjects(converter) {
+        const deduplicatedColumnNames = this.deduplicatedColumnNames();
+        for await (const chunk of this) {
+            yield (0, convertRowObjectsFromChunks_1.convertRowObjectsFromChunks)([chunk], deduplicatedColumnNames, converter);
+        }
+    }
+    yieldRowsJs() {
+        return this.yieldConvertedRows(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
+    }
+    yieldRowsJson() {
+        return this.yieldConvertedRows(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
+    }
+    yieldRowObjectJs() {
+        return this.yieldConvertedRowObjects(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
+    }
+    yieldRowObjectJson() {
+        return this.yieldConvertedRowObjects(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
+    }
+}
+exports.DuckDBResult = DuckDBResult;

package/lib/DuckDBResultReader.d.ts

@@ -0,0 +1,68 @@
+import { DuckDBLogicalType } from './DuckDBLogicalType';
+import { DuckDBResult } from './DuckDBResult';
+import { DuckDBType } from './DuckDBType';
+import { DuckDBTypeId } from './DuckDBTypeId';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+import { ResultReturnType, StatementType } from './enums';
+import { JS } from './JS';
+import { Json } from './Json';
+import { DuckDBValue } from './values';
+export declare class DuckDBResultReader {
+    private readonly result;
+    private readonly chunks;
+    private readonly chunkSizeRuns;
+    private currentRowCount_;
+    private done_;
+    constructor(result: DuckDBResult);
+    get returnType(): ResultReturnType;
+    get statementType(): StatementType;
+    get columnCount(): number;
+    columnName(columnIndex: number): string;
+    columnNames(): string[];
+    deduplicatedColumnNames(): string[];
+    columnTypeId(columnIndex: number): DuckDBTypeId;
+    columnLogicalType(columnIndex: number): DuckDBLogicalType;
+    columnType(columnIndex: number): DuckDBType;
+    columnTypeJson(columnIndex: number): Json;
+    columnTypes(): DuckDBType[];
+    columnTypesJson(): Json;
+    columnNamesAndTypesJson(): Json;
+    columnNameAndTypeObjectsJson(): Json;
+    get rowsChanged(): number;
+    /** Total number of rows read so far. Call `readAll` or `readUntil` to read rows. */
+    get currentRowCount(): number;
+    /** Whether reading is done, that is, there are no more rows to read. */
+    get done(): boolean;
+    /**
+     * Returns the value for the given column and row. Both are zero-indexed.
+     *
+     * Will return an error if `rowIndex` is greater than `currentRowCount`.
+     */
+    value(columnIndex: number, rowIndex: number): DuckDBValue;
+    /** Read all rows. */
+    readAll(): Promise<void>;
+    /**
+     * Read rows until at least the given target row count has been met.
+     *
+     * Note that the resulting row count could be greater than the target, since rows are read in chunks, typically of 2048 rows each.
+     */
+    readUntil(targetRowCount: number): Promise<void>;
+    private fetchChunks;
+    private updateChunkSizeRuns;
+    getColumns(): DuckDBValue[][];
+    convertColumns<T>(converter: DuckDBValueConverter<T>): (T | null)[][];
+    getColumnsJS(): JS[][];
+    getColumnsJson(): Json[][];
+    getColumnsObject(): Record<string, DuckDBValue[]>;
+    convertColumnsObject<T>(converter: DuckDBValueConverter<T>): Record<string, (T | null)[]>;
+    getColumnsObjectJS(): Record<string, JS[]>;
+    getColumnsObjectJson(): Record<string, Json[]>;
+    getRows(): DuckDBValue[][];
+    convertRows<T>(converter: DuckDBValueConverter<T>): (T | null)[][];
+    getRowsJS(): JS[][];
+    getRowsJson(): Json[][];
+    getRowObjects(): Record<string, DuckDBValue>[];
+    convertRowObjects<T>(converter: DuckDBValueConverter<T>): Record<string, T | null>[];
+    getRowObjectsJS(): Record<string, JS>[];
+    getRowObjectsJson(): Record<string, Json>[];
+}