@duckdb/node-api 1.1.3-alpha.9 → 1.2.0-alpha.14

package/lib/DuckDBDataChunk.js

@@ -13,7 +13,7 @@ class DuckDBDataChunk {
         this.chunk = chunk;
     }
     static create(types, rowCount) {
-        const chunk = new DuckDBDataChunk(node_bindings_1.default.create_data_chunk(types.map(t => t.toLogicalType().logical_type)));
+        const chunk = new DuckDBDataChunk(node_bindings_1.default.create_data_chunk(types.map((t) => t.toLogicalType().logical_type)));
         if (rowCount != undefined) {
             chunk.rowCount = rowCount;
         }
@@ -25,6 +25,12 @@ class DuckDBDataChunk {
     get columnCount() {
         return node_bindings_1.default.data_chunk_get_column_count(this.chunk);
     }
+    get rowCount() {
+        return node_bindings_1.default.data_chunk_get_size(this.chunk);
+    }
+    set rowCount(count) {
+        node_bindings_1.default.data_chunk_set_size(this.chunk, count);
+    }
     getColumnVector(columnIndex) {
         if (this.vectors[columnIndex]) {
             return this.vectors[columnIndex];
@@ -33,8 +39,23 @@ class DuckDBDataChunk {
         this.vectors[columnIndex] = vector;
         return vector;
     }
+    visitColumnValues(columnIndex, visitValue) {
+        const vector = this.getColumnVector(columnIndex);
+        const type = vector.type;
+        for (let rowIndex = 0; rowIndex < vector.itemCount; rowIndex++) {
+            visitValue(vector.getItem(rowIndex), rowIndex, columnIndex, type);
+        }
+    }
     getColumnValues(columnIndex) {
-        return this.getColumnVector(columnIndex).toArray();
+        const values = [];
+        this.visitColumnValues(columnIndex, (value) => values.push(value));
+        return values;
+    }
+    convertColumnValues(columnIndex, converter) {
+        const convertedValues = [];
+        const type = this.getColumnVector(columnIndex).type;
+        this.visitColumnValues(columnIndex, (value) => convertedValues.push(converter.convertValue(value, type)));
+        return convertedValues;
     }
     setColumnValues(columnIndex, values) {
         const vector = this.getColumnVector(columnIndex);
@@ -46,13 +67,24 @@ class DuckDBDataChunk {
         }
         vector.flush();
     }
+    visitColumns(visitColumn) {
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            visitColumn(this.getColumnValues(columnIndex), columnIndex, this.getColumnVector(columnIndex).type);
+        }
+    }
     getColumns() {
         const columns = [];
+        this.visitColumns((column) => columns.push(column));
+        return columns;
+    }
+    convertColumns(converter) {
+        const convertedColumns = [];
         const columnCount = this.columnCount;
         for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
-            columns.push(this.getColumnValues(columnIndex));
+            convertedColumns.push(this.convertColumnValues(columnIndex, converter));
         }
-        return columns;
+        return convertedColumns;
     }
     setColumns(columns) {
         if (columns.length > 0) {
@@ -62,23 +94,48 @@ class DuckDBDataChunk {
             this.setColumnValues(columnIndex, columns[columnIndex]);
         }
     }
-    getRows() {
-        const rows = [];
-        const vectors = [];
+    visitColumnMajor(visitValue) {
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            this.visitColumnValues(columnIndex, visitValue);
+        }
+    }
+    visitRowValues(rowIndex, visitValue) {
         const columnCount = this.columnCount;
         for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
-            vectors.push(this.getColumnVector(columnIndex));
+            const vector = this.getColumnVector(columnIndex);
+            visitValue(vector.getItem(rowIndex), rowIndex, columnIndex, vector.type);
         }
+    }
+    getRowValues(rowIndex) {
+        const values = [];
+        this.visitRowValues(rowIndex, (value) => values.push(value));
+        return values;
+    }
+    convertRowValues(rowIndex, converter) {
+        const convertedValues = [];
+        this.visitRowValues(rowIndex, (value, _, columnIndex) => convertedValues.push(converter.convertValue(value, this.getColumnVector(columnIndex).type)));
+        return convertedValues;
+    }
+    visitRows(visitRow) {
         const rowCount = this.rowCount;
         for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
-            const row = [];
-            for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
-                row.push(vectors[columnIndex].getItem(rowIndex));
-            }
-            rows.push(row);
+            visitRow(this.getRowValues(rowIndex), rowIndex);
         }
+    }
+    getRows() {
+        const rows = [];
+        this.visitRows((row) => rows.push(row));
         return rows;
     }
+    convertRows(converter) {
+        const convertedRows = [];
+        const rowCount = this.rowCount;
+        for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+            convertedRows.push(this.convertRowValues(rowIndex, converter));
+        }
+        return convertedRows;
+    }
     setRows(rows) {
         this.rowCount = rows.length;
         const columnCount = this.columnCount;
@@ -90,11 +147,15 @@ class DuckDBDataChunk {
             vector.flush();
         }
     }
-    get rowCount() {
-        return node_bindings_1.default.data_chunk_get_size(this.chunk);
-    }
-    set rowCount(count) {
-        node_bindings_1.default.data_chunk_set_size(this.chunk, count);
+    visitRowMajor(visitValue) {
+        const rowCount = this.rowCount;
+        const columnCount = this.columnCount;
+        for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+            for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+                const vector = this.getColumnVector(columnIndex);
+                visitValue(vector.getItem(rowIndex), rowIndex, columnIndex, vector.type);
+            }
+        }
     }
 }
 exports.DuckDBDataChunk = DuckDBDataChunk;

package/lib/DuckDBLogicalType.d.ts

@@ -14,7 +14,7 @@ export declare class DuckDBLogicalType {
     static createUnion(memberTags: readonly string[], memberLogicalTypes: readonly DuckDBLogicalType[]): DuckDBUnionLogicalType;
     get typeId(): DuckDBTypeId;
     get alias(): string | undefined;
-    set alias(newAlias: string);
+    set alias(newAlias: string | null | undefined);
     asType(): DuckDBType;
 }
 export declare class DuckDBDecimalLogicalType extends DuckDBLogicalType {

package/lib/DuckDBLogicalType.js

@@ -82,7 +82,7 @@ class DuckDBLogicalType {
         return node_bindings_1.default.logical_type_get_alias(this.logical_type) || undefined;
     }
     set alias(newAlias) {
-        node_bindings_1.default.logical_type_set_alias(this.logical_type, newAlias);
+        node_bindings_1.default.logical_type_set_alias(this.logical_type, newAlias || '');
     }
     asType() {
         const alias = this.alias;

package/lib/DuckDBPreparedStatement.d.ts

@@ -14,6 +14,7 @@ export declare class DuckDBPreparedStatement {
     get parameterCount(): number;
     parameterName(parameterIndex: number): string;
     parameterTypeId(parameterIndex: number): DuckDBTypeId;
+    parameterType(parameterIndex: number): DuckDBType;
     clearBindings(): void;
     parameterIndex(parameterName: string): number;
     bindBoolean(parameterIndex: number, value: boolean): void;
@@ -43,7 +44,7 @@ export declare class DuckDBPreparedStatement {
     bindStruct(parameterIndex: number, value: DuckDBStructValue, type: DuckDBStructType): void;
     bindNull(parameterIndex: number): void;
     bindValue(parameterIndex: number, value: DuckDBValue, type: DuckDBType): void;
-    bind(values: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType>): void;
+    bind(values: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): void;
     run(): Promise<DuckDBMaterializedResult>;
     runAndRead(): Promise<DuckDBResultReader>;
     runAndReadAll(): Promise<DuckDBResultReader>;

package/lib/DuckDBPreparedStatement.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DuckDBPreparedStatement = void 0;
 const node_bindings_1 = __importDefault(require("@duckdb/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");
@@ -29,6 +30,9 @@ class DuckDBPreparedStatement {
     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();
+    }
     clearBindings() {
         node_bindings_1.default.clear_bindings(this.prepared_statement);
     }
@@ -132,7 +136,11 @@ class DuckDBPreparedStatement {
             const typesIsRecord = types && !Array.isArray(types);
             for (const key in values) {
                 const index = this.parameterIndex(key);
-                this.bindValue(index, values[key], typesIsRecord ? types[key] : (0, typeForValue_1.typeForValue)(values[key]));
+                let type = typesIsRecord ? types[key] : undefined;
+                if (type === undefined) {
+                    type = (0, typeForValue_1.typeForValue)(values[key]);
+                }
+                this.bindValue(index, values[key], type);
             }
         }
     }

package/lib/DuckDBResult.d.ts

@@ -3,6 +3,7 @@ import { DuckDBDataChunk } from './DuckDBDataChunk';
 import { DuckDBLogicalType } from './DuckDBLogicalType';
 import { DuckDBType } from './DuckDBType';
 import { DuckDBTypeId } from './DuckDBTypeId';
+import { Json } from './DuckDBValueToJsonConverter';
 import { ResultReturnType, StatementType } from './enums';
 import { DuckDBValue } from './values';
 export declare class DuckDBResult {
@@ -13,6 +14,7 @@ export declare class DuckDBResult {
     get columnCount(): number;
     columnName(columnIndex: number): string;
     columnNames(): string[];
+    deduplicatedColumnNames(): string[];
     columnTypeId(columnIndex: number): DuckDBTypeId;
     columnLogicalType(columnIndex: number): DuckDBLogicalType;
     columnType(columnIndex: number): DuckDBType;
@@ -22,5 +24,11 @@ export declare class DuckDBResult {
     fetchChunk(): Promise<DuckDBDataChunk | null>;
     fetchAllChunks(): Promise<DuckDBDataChunk[]>;
     getColumns(): Promise<DuckDBValue[][]>;
+    getColumnsJson(): Promise<Json[][]>;
+    getColumnsObject(): Promise<Record<string, DuckDBValue[]>>;
+    getColumnsObjectJson(): Promise<Record<string, Json[]>>;
     getRows(): Promise<DuckDBValue[][]>;
+    getRowsJson(): Promise<Json[][]>;
+    getRowObjects(): Promise<Record<string, DuckDBValue>[]>;
+    getRowObjectsJson(): Promise<Record<string, Json>[]>;
 }

package/lib/DuckDBResult.js

@@ -7,6 +7,15 @@ exports.DuckDBResult = void 0;
 const node_bindings_1 = __importDefault(require("@duckdb/node-bindings"));
 const DuckDBDataChunk_1 = require("./DuckDBDataChunk");
 const DuckDBLogicalType_1 = require("./DuckDBLogicalType");
+const DuckDBValueToJsonConverter_1 = require("./DuckDBValueToJsonConverter");
+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) {
@@ -32,6 +41,23 @@ class DuckDBResult {
         }
         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);
     }
@@ -71,44 +97,35 @@ class DuckDBResult {
     }
     async getColumns() {
         const chunks = await this.fetchAllChunks();
-        if (chunks.length === 0) {
-            return [];
-        }
-        const firstChunk = chunks[0];
-        const columns = [];
-        const columnCount = this.columnCount;
-        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
-            columns.push(firstChunk.getColumnValues(columnIndex));
-        }
-        for (let chunkIndex = 1; chunkIndex < chunks.length; chunkIndex++) {
-            for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
-                const vector = chunks[chunkIndex].getColumnVector(columnIndex);
-                for (let itemIndex = 0; itemIndex < vector.itemCount; itemIndex++) {
-                    columns[columnIndex].push(vector.getItem(itemIndex));
-                }
-            }
-        }
-        return columns;
+        return (0, getColumnsFromChunks_1.getColumnsFromChunks)(chunks);
+    }
+    async getColumnsJson() {
+        const chunks = await this.fetchAllChunks();
+        return (0, convertColumnsFromChunks_1.convertColumnsFromChunks)(chunks, DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
+    }
+    async getColumnsObject() {
+        const chunks = await this.fetchAllChunks();
+        return (0, getColumnsObjectFromChunks_1.getColumnsObjectFromChunks)(chunks, this.deduplicatedColumnNames());
+    }
+    async getColumnsObjectJson() {
+        const chunks = await this.fetchAllChunks();
+        return (0, convertColumnsObjectFromChunks_1.convertColumnsObjectFromChunks)(chunks, this.deduplicatedColumnNames(), DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
     }
     async getRows() {
         const chunks = await this.fetchAllChunks();
-        const rows = [];
-        for (const chunk of chunks) {
-            const chunkVectors = [];
-            const columnCount = chunk.columnCount;
-            for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
-                chunkVectors.push(chunk.getColumnVector(columnIndex));
-            }
-            const rowCount = chunk.rowCount;
-            for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
-                const row = [];
-                for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
-                    row.push(chunkVectors[columnIndex].getItem(rowIndex));
-                }
-                rows.push(row);
-            }
-        }
-        return rows;
+        return (0, getRowsFromChunks_1.getRowsFromChunks)(chunks);
+    }
+    async getRowsJson() {
+        const chunks = await this.fetchAllChunks();
+        return (0, convertRowsFromChunks_1.convertRowsFromChunks)(chunks, DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
+    }
+    async getRowObjects() {
+        const chunks = await this.fetchAllChunks();
+        return (0, getRowObjectsFromChunks_1.getRowObjectsFromChunks)(chunks, this.deduplicatedColumnNames());
+    }
+    async getRowObjectsJson() {
+        const chunks = await this.fetchAllChunks();
+        return (0, convertRowObjectsFromChunks_1.convertRowObjectsFromChunks)(chunks, this.deduplicatedColumnNames(), DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
     }
 }
 exports.DuckDBResult = DuckDBResult;

package/lib/DuckDBResultReader.d.ts

@@ -2,6 +2,7 @@ import { DuckDBLogicalType } from './DuckDBLogicalType';
 import { DuckDBResult } from './DuckDBResult';
 import { DuckDBType } from './DuckDBType';
 import { DuckDBTypeId } from './DuckDBTypeId';
+import { Json } from './DuckDBValueToJsonConverter';
 import { ResultReturnType, StatementType } from './enums';
 import { DuckDBValue } from './values';
 export declare class DuckDBResultReader {
@@ -16,6 +17,7 @@ export declare class DuckDBResultReader {
     get columnCount(): number;
     columnName(columnIndex: number): string;
     columnNames(): string[];
+    deduplicatedColumnNames(): string[];
     columnTypeId(columnIndex: number): DuckDBTypeId;
     columnLogicalType(columnIndex: number): DuckDBLogicalType;
     columnType(columnIndex: number): DuckDBType;
@@ -42,5 +44,11 @@ export declare class DuckDBResultReader {
     private fetchChunks;
     private updateChunkSizeRuns;
     getColumns(): DuckDBValue[][];
+    getColumnsJson(): Json[][];
+    getColumnsObject(): Record<string, DuckDBValue[]>;
+    getColumnsObjectJson(): Record<string, Json[]>;
     getRows(): DuckDBValue[][];
+    getRowsJson(): Json[][];
+    getRowObjects(): Record<string, DuckDBValue>[];
+    getRowObjectsJson(): Record<string, Json>[];
 }

package/lib/DuckDBResultReader.js

@@ -1,6 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DuckDBResultReader = void 0;
+const convertColumnsFromChunks_1 = require("./convertColumnsFromChunks");
+const convertColumnsObjectFromChunks_1 = require("./convertColumnsObjectFromChunks");
+const convertRowObjectsFromChunks_1 = require("./convertRowObjectsFromChunks");
+const convertRowsFromChunks_1 = require("./convertRowsFromChunks");
+const DuckDBValueToJsonConverter_1 = require("./DuckDBValueToJsonConverter");
+const getColumnsFromChunks_1 = require("./getColumnsFromChunks");
+const getColumnsObjectFromChunks_1 = require("./getColumnsObjectFromChunks");
+const getRowObjectsFromChunks_1 = require("./getRowObjectsFromChunks");
+const getRowsFromChunks_1 = require("./getRowsFromChunks");
 class DuckDBResultReader {
     result;
     chunks;
@@ -29,6 +38,9 @@ class DuckDBResultReader {
     columnNames() {
         return this.result.columnNames();
     }
+    deduplicatedColumnNames() {
+        return this.result.deduplicatedColumnNames();
+    }
     columnTypeId(columnIndex) {
         return this.result.columnTypeId(columnIndex);
     }
@@ -96,7 +108,8 @@ class DuckDBResultReader {
     }
     async fetchChunks(targetRowCount) {
         while (!(this.done_ ||
-            (targetRowCount !== undefined && this.currentRowCount_ >= targetRowCount))) {
+            (targetRowCount !== undefined &&
+                this.currentRowCount_ >= targetRowCount))) {
             const chunk = await this.result.fetchChunk();
             if (chunk && chunk.rowCount > 0) {
                 this.updateChunkSizeRuns(chunk);
@@ -126,43 +139,28 @@ class DuckDBResultReader {
         });
     }
     getColumns() {
-        if (this.chunks.length === 0) {
-            return [];
-        }
-        const firstChunk = this.chunks[0];
-        const columns = [];
-        const columnCount = this.columnCount;
-        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
-            columns.push(firstChunk.getColumnValues(columnIndex));
-        }
-        for (let chunkIndex = 1; chunkIndex < this.chunks.length; chunkIndex++) {
-            for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
-                const vector = this.chunks[chunkIndex].getColumnVector(columnIndex);
-                for (let itemIndex = 0; itemIndex < vector.itemCount; itemIndex++) {
-                    columns[columnIndex].push(vector.getItem(itemIndex));
-                }
-            }
-        }
-        return columns;
+        return (0, getColumnsFromChunks_1.getColumnsFromChunks)(this.chunks);
+    }
+    getColumnsJson() {
+        return (0, convertColumnsFromChunks_1.convertColumnsFromChunks)(this.chunks, DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
+    }
+    getColumnsObject() {
+        return (0, getColumnsObjectFromChunks_1.getColumnsObjectFromChunks)(this.chunks, this.deduplicatedColumnNames());
+    }
+    getColumnsObjectJson() {
+        return (0, convertColumnsObjectFromChunks_1.convertColumnsObjectFromChunks)(this.chunks, this.deduplicatedColumnNames(), DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
     }
     getRows() {
-        const rows = [];
-        for (const chunk of this.chunks) {
-            const chunkVectors = [];
-            const columnCount = chunk.columnCount;
-            for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
-                chunkVectors.push(chunk.getColumnVector(columnIndex));
-            }
-            const rowCount = chunk.rowCount;
-            for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
-                const row = [];
-                for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
-                    row.push(chunkVectors[columnIndex].getItem(rowIndex));
-                }
-                rows.push(row);
-            }
-        }
-        return rows;
+        return (0, getRowsFromChunks_1.getRowsFromChunks)(this.chunks);
+    }
+    getRowsJson() {
+        return (0, convertRowsFromChunks_1.convertRowsFromChunks)(this.chunks, DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
+    }
+    getRowObjects() {
+        return (0, getRowObjectsFromChunks_1.getRowObjectsFromChunks)(this.chunks, this.deduplicatedColumnNames());
+    }
+    getRowObjectsJson() {
+        return (0, convertRowObjectsFromChunks_1.convertRowObjectsFromChunks)(this.chunks, this.deduplicatedColumnNames(), DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
     }
 }
 exports.DuckDBResultReader = DuckDBResultReader;

package/lib/DuckDBType.d.ts

@@ -200,6 +200,8 @@ export declare class DuckDBTimestampSecondsType extends BaseDuckDBType<DuckDBTyp
     get epoch(): DuckDBTimestampSecondsValue;
     get max(): DuckDBTimestampSecondsValue;
     get min(): DuckDBTimestampSecondsValue;
+    get posInf(): DuckDBTimestampSecondsValue;
+    get negInf(): DuckDBTimestampSecondsValue;
 }
 export declare const TIMESTAMP_S: DuckDBTimestampSecondsType;
 export declare class DuckDBTimestampMillisecondsType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_MS> {
@@ -209,6 +211,8 @@ export declare class DuckDBTimestampMillisecondsType extends BaseDuckDBType<Duck
     get epoch(): DuckDBTimestampMillisecondsValue;
     get max(): DuckDBTimestampMillisecondsValue;
     get min(): DuckDBTimestampMillisecondsValue;
+    get posInf(): DuckDBTimestampMillisecondsValue;
+    get negInf(): DuckDBTimestampMillisecondsValue;
 }
 export declare const TIMESTAMP_MS: DuckDBTimestampMillisecondsType;
 export declare class DuckDBTimestampNanosecondsType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_NS> {
@@ -218,6 +222,8 @@ export declare class DuckDBTimestampNanosecondsType extends BaseDuckDBType<DuckD
     get epoch(): DuckDBTimestampNanosecondsValue;
     get max(): DuckDBTimestampNanosecondsValue;
     get min(): DuckDBTimestampNanosecondsValue;
+    get posInf(): DuckDBTimestampNanosecondsValue;
+    get negInf(): DuckDBTimestampNanosecondsValue;
 }
 export declare const TIMESTAMP_NS: DuckDBTimestampNanosecondsType;
 export declare class DuckDBEnumType extends BaseDuckDBType<DuckDBTypeId.ENUM> {
@@ -243,8 +249,11 @@ export declare function LIST(valueType: DuckDBType, alias?: string): DuckDBListT
 export declare class DuckDBStructType extends BaseDuckDBType<DuckDBTypeId.STRUCT> {
     readonly entryNames: readonly string[];
     readonly entryTypes: readonly DuckDBType[];
+    readonly entryIndexes: Readonly<Record<string, number>>;
     constructor(entryNames: readonly string[], entryTypes: readonly DuckDBType[], alias?: string);
     get entryCount(): number;
+    indexForEntry(entryName: string): number;
+    typeForEntry(entryName: string): DuckDBType;
     toString(): string;
     toLogicalType(): DuckDBLogicalType;
 }
@@ -279,6 +288,7 @@ export declare class DuckDBUnionType extends BaseDuckDBType<DuckDBTypeId.UNION>
     readonly memberTypes: readonly DuckDBType[];
     constructor(memberTags: readonly string[], memberTypes: readonly DuckDBType[], alias?: string);
     memberIndexForTag(tag: string): number;
+    memberTypeForTag(tag: string): DuckDBType;
     get memberCount(): number;
     toString(): string;
     toLogicalType(): DuckDBLogicalType;

package/lib/DuckDBType.js

@@ -434,6 +434,12 @@ class DuckDBTimestampSecondsType extends BaseDuckDBType {
     get min() {
         return values_1.DuckDBTimestampSecondsValue.Min;
     }
+    get posInf() {
+        return values_1.DuckDBTimestampSecondsValue.PosInf;
+    }
+    get negInf() {
+        return values_1.DuckDBTimestampSecondsValue.NegInf;
+    }
 }
 exports.DuckDBTimestampSecondsType = DuckDBTimestampSecondsType;
 exports.TIMESTAMP_S = DuckDBTimestampSecondsType.instance;
@@ -456,6 +462,12 @@ class DuckDBTimestampMillisecondsType extends BaseDuckDBType {
     get min() {
         return values_1.DuckDBTimestampMillisecondsValue.Min;
     }
+    get posInf() {
+        return values_1.DuckDBTimestampMillisecondsValue.PosInf;
+    }
+    get negInf() {
+        return values_1.DuckDBTimestampMillisecondsValue.NegInf;
+    }
 }
 exports.DuckDBTimestampMillisecondsType = DuckDBTimestampMillisecondsType;
 exports.TIMESTAMP_MS = DuckDBTimestampMillisecondsType.instance;
@@ -478,6 +490,12 @@ class DuckDBTimestampNanosecondsType extends BaseDuckDBType {
     get min() {
         return values_1.DuckDBTimestampNanosecondsValue.Min;
     }
+    get posInf() {
+        return values_1.DuckDBTimestampNanosecondsValue.PosInf;
+    }
+    get negInf() {
+        return values_1.DuckDBTimestampNanosecondsValue.NegInf;
+    }
 }
 exports.DuckDBTimestampNanosecondsType = DuckDBTimestampNanosecondsType;
 exports.TIMESTAMP_NS = DuckDBTimestampNanosecondsType.instance;
@@ -557,6 +575,7 @@ function LIST(valueType, alias) {
 class DuckDBStructType extends BaseDuckDBType {
     entryNames;
     entryTypes;
+    entryIndexes;
     constructor(entryNames, entryTypes, alias) {
         super(DuckDBTypeId_1.DuckDBTypeId.STRUCT, alias);
         if (entryNames.length !== entryTypes.length) {
@@ -565,10 +584,21 @@ class DuckDBStructType extends BaseDuckDBType {
         }
         this.entryNames = entryNames;
         this.entryTypes = entryTypes;
+        const entryIndexes = {};
+        for (let i = 0; i < entryNames.length; i++) {
+            entryIndexes[entryNames[i]] = i;
+        }
+        this.entryIndexes = entryIndexes;
     }
     get entryCount() {
         return this.entryNames.length;
     }
+    indexForEntry(entryName) {
+        return this.entryIndexes[entryName];
+    }
+    typeForEntry(entryName) {
+        return this.entryTypes[this.entryIndexes[entryName]];
+    }
     toString() {
         const parts = [];
         for (let i = 0; i < this.entryNames.length; i++) {
@@ -674,6 +704,9 @@ class DuckDBUnionType extends BaseDuckDBType {
     memberIndexForTag(tag) {
         return this.tagMemberIndexes[tag];
     }
+    memberTypeForTag(tag) {
+        return this.memberTypes[this.tagMemberIndexes[tag]];
+    }
     get memberCount() {
         return this.memberTags.length;
     }

package/lib/DuckDBValueConverter.d.ts

@@ -0,0 +1,5 @@
+import { DuckDBType } from './DuckDBType';
+import { DuckDBValue } from './values';
+export interface DuckDBValueConverter<T> {
+    convertValue(value: DuckDBValue, type: DuckDBType): T;
+}

package/lib/DuckDBValueConverter.js

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

package/lib/DuckDBValueToJsonConverter.d.ts

@@ -0,0 +1,10 @@
+import { DuckDBType } from './DuckDBType';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+import { DuckDBValue } from './values';
+export type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+export declare class DuckDBValueToJsonConverter implements DuckDBValueConverter<Json> {
+    static readonly default: DuckDBValueToJsonConverter;
+    convertValue(value: DuckDBValue, type: DuckDBType): Json;
+}