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

package/lib/DuckDBValueToJsonConverter.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBValueToJsonConverter = void 0;
+const DuckDBTypeId_1 = require("./DuckDBTypeId");
+const values_1 = require("./values");
+class DuckDBValueToJsonConverter {
+    static default = new DuckDBValueToJsonConverter();
+    convertValue(value, type) {
+        if (value == null) {
+            return null;
+        }
+        switch (type.typeId) {
+            case DuckDBTypeId_1.DuckDBTypeId.BOOLEAN:
+                return Boolean(value);
+            case DuckDBTypeId_1.DuckDBTypeId.TINYINT:
+            case DuckDBTypeId_1.DuckDBTypeId.SMALLINT:
+            case DuckDBTypeId_1.DuckDBTypeId.INTEGER:
+            case DuckDBTypeId_1.DuckDBTypeId.UTINYINT:
+            case DuckDBTypeId_1.DuckDBTypeId.USMALLINT:
+            case DuckDBTypeId_1.DuckDBTypeId.UINTEGER:
+                return Number(value);
+            case DuckDBTypeId_1.DuckDBTypeId.FLOAT:
+            case DuckDBTypeId_1.DuckDBTypeId.DOUBLE:
+                if (Number.isFinite(value)) {
+                    return Number(value);
+                }
+                return String(value);
+            case DuckDBTypeId_1.DuckDBTypeId.BIGINT:
+            case DuckDBTypeId_1.DuckDBTypeId.UBIGINT:
+            case DuckDBTypeId_1.DuckDBTypeId.HUGEINT:
+            case DuckDBTypeId_1.DuckDBTypeId.UHUGEINT:
+                return String(value);
+            case DuckDBTypeId_1.DuckDBTypeId.DATE:
+            case DuckDBTypeId_1.DuckDBTypeId.TIME:
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP:
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_S:
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_MS:
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_NS:
+            case DuckDBTypeId_1.DuckDBTypeId.TIME_TZ:
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_TZ:
+                return String(value);
+            case DuckDBTypeId_1.DuckDBTypeId.INTERVAL:
+                if (value instanceof values_1.DuckDBIntervalValue) {
+                    return {
+                        months: value.months,
+                        days: value.days,
+                        micros: String(value.micros),
+                    };
+                }
+                return null;
+            case DuckDBTypeId_1.DuckDBTypeId.VARCHAR:
+            case DuckDBTypeId_1.DuckDBTypeId.BLOB:
+            case DuckDBTypeId_1.DuckDBTypeId.BIT:
+                return String(value);
+            case DuckDBTypeId_1.DuckDBTypeId.DECIMAL:
+            case DuckDBTypeId_1.DuckDBTypeId.VARINT:
+                return String(value);
+            case DuckDBTypeId_1.DuckDBTypeId.ENUM:
+                return String(value);
+            case DuckDBTypeId_1.DuckDBTypeId.LIST:
+                if (value instanceof values_1.DuckDBListValue) {
+                    return value.items.map((v) => this.convertValue(v, type.valueType));
+                }
+                return null;
+            case DuckDBTypeId_1.DuckDBTypeId.STRUCT:
+                if (value instanceof values_1.DuckDBStructValue) {
+                    const result = {};
+                    for (const key in value.entries) {
+                        result[key] = this.convertValue(value.entries[key], type.typeForEntry(key));
+                    }
+                    return result;
+                }
+                return null;
+            case DuckDBTypeId_1.DuckDBTypeId.MAP:
+                if (value instanceof values_1.DuckDBMapValue) {
+                    return value.entries.map((entry) => ({
+                        key: this.convertValue(entry.key, type.keyType),
+                        value: this.convertValue(entry.value, type.valueType),
+                    }));
+                }
+                return null;
+            case DuckDBTypeId_1.DuckDBTypeId.ARRAY:
+                if (value instanceof values_1.DuckDBArrayValue) {
+                    return value.items.map((v) => this.convertValue(v, type.valueType));
+                }
+                return null;
+            case DuckDBTypeId_1.DuckDBTypeId.UNION:
+                if (value instanceof values_1.DuckDBUnionValue) {
+                    return {
+                        tag: value.tag,
+                        value: this.convertValue(value.value, type.memberTypeForTag(value.tag)),
+                    };
+                }
+                return null;
+            case DuckDBTypeId_1.DuckDBTypeId.UUID:
+                return String(value);
+        }
+        return null;
+    }
+}
+exports.DuckDBValueToJsonConverter = DuckDBValueToJsonConverter;

package/lib/DuckDBVector.js

@@ -1628,7 +1628,7 @@ class DuckDBTimestampMillisecondsVector extends DuckDBVector {
     }
     setItem(itemIndex, value) {
         if (value != null) {
-            this.items[itemIndex] = value.milliseconds;
+            this.items[itemIndex] = value.millis;
             this.validity.setItemValid(itemIndex, true);
         }
         else {
@@ -1673,7 +1673,7 @@ class DuckDBTimestampNanosecondsVector extends DuckDBVector {
     }
     setItem(itemIndex, value) {
         if (value != null) {
-            this.items[itemIndex] = value.nanoseconds;
+            this.items[itemIndex] = value.nanos;
             this.validity.setItemValid(itemIndex, true);
         }
         else {

package/lib/conversion/dateTimeStringConversion.d.ts

@@ -1,5 +1,9 @@
 export declare function getDuckDBDateStringFromYearMonthDay(year: number, month: number, dayOfMonth: number): string;
 export declare function getDuckDBDateStringFromDays(days: number): string;
+export declare function getTimezoneOffsetString(timezoneOffsetInMinutes?: number): string | undefined;
+export declare function getAbsoluteOffsetStringFromParts(hoursPart: number, minutesPart: number, secondsPart: number): string;
+export declare function getOffsetStringFromAbsoluteSeconds(absoluteOffsetInSeconds: number): string;
+export declare function getOffsetStringFromSeconds(offsetInSeconds: number): string;
 export declare function getDuckDBTimeStringFromParts(hoursPart: bigint, minutesPart: bigint, secondsPart: bigint, microsecondsPart: bigint): string;
 export declare function getDuckDBTimeStringFromPartsNS(hoursPart: bigint, minutesPart: bigint, secondsPart: bigint, nanosecondsPart: bigint): string;
 export declare function getDuckDBTimeStringFromPositiveMicroseconds(positiveMicroseconds: bigint): string;
@@ -7,10 +11,10 @@ export declare function getDuckDBTimeStringFromPositiveNanoseconds(positiveNanos
 export declare function getDuckDBTimeStringFromMicrosecondsInDay(microsecondsInDay: bigint): string;
 export declare function getDuckDBTimeStringFromNanosecondsInDay(nanosecondsInDay: bigint): string;
 export declare function getDuckDBTimeStringFromMicroseconds(microseconds: bigint): string;
-export declare function getDuckDBTimestampStringFromDaysAndMicroseconds(days: bigint, microsecondsInDay: bigint, timezone?: string | null): string;
-export declare function getDuckDBTimestampStringFromDaysAndNanoseconds(days: bigint, nanosecondsInDay: bigint, timezone?: string | null): string;
-export declare function getDuckDBTimestampStringFromMicroseconds(microseconds: bigint, timezone?: string | null): string;
-export declare function getDuckDBTimestampStringFromSeconds(seconds: bigint, timezone?: string | null): string;
-export declare function getDuckDBTimestampStringFromMilliseconds(milliseconds: bigint, timezone?: string | null): string;
-export declare function getDuckDBTimestampStringFromNanoseconds(nanoseconds: bigint, timezone?: string | null): string;
+export declare function getDuckDBTimestampStringFromDaysAndMicroseconds(days: bigint, microsecondsInDay: bigint, timezonePart?: string): string;
+export declare function getDuckDBTimestampStringFromDaysAndNanoseconds(days: bigint, nanosecondsInDay: bigint): string;
+export declare function getDuckDBTimestampStringFromMicroseconds(microseconds: bigint, timezoneOffsetInMinutes?: number): string;
+export declare function getDuckDBTimestampStringFromSeconds(seconds: bigint): string;
+export declare function getDuckDBTimestampStringFromMilliseconds(milliseconds: bigint): string;
+export declare function getDuckDBTimestampStringFromNanoseconds(nanoseconds: bigint): string;
 export declare function getDuckDBIntervalString(months: number, days: number, microseconds: bigint): string;

package/lib/conversion/dateTimeStringConversion.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDuckDBDateStringFromYearMonthDay = getDuckDBDateStringFromYearMonthDay;
 exports.getDuckDBDateStringFromDays = getDuckDBDateStringFromDays;
+exports.getTimezoneOffsetString = getTimezoneOffsetString;
+exports.getAbsoluteOffsetStringFromParts = getAbsoluteOffsetStringFromParts;
+exports.getOffsetStringFromAbsoluteSeconds = getOffsetStringFromAbsoluteSeconds;
+exports.getOffsetStringFromSeconds = getOffsetStringFromSeconds;
 exports.getDuckDBTimeStringFromParts = getDuckDBTimeStringFromParts;
 exports.getDuckDBTimeStringFromPartsNS = getDuckDBTimeStringFromPartsNS;
 exports.getDuckDBTimeStringFromPositiveMicroseconds = getDuckDBTimeStringFromPositiveMicroseconds;
@@ -56,6 +60,46 @@ function getDuckDBDateStringFromDays(days) {
     const dayOfMonth = date.getUTCDate(); // getUTCDate returns one-indexed day-of-month
     return getDuckDBDateStringFromYearMonthDay(year, month, dayOfMonth);
 }
+function getTimezoneOffsetString(timezoneOffsetInMinutes) {
+    if (timezoneOffsetInMinutes === undefined) {
+        return undefined;
+    }
+    const negative = timezoneOffsetInMinutes < 0;
+    const positiveMinutes = Math.abs(timezoneOffsetInMinutes);
+    const minutesPart = positiveMinutes % 60;
+    const hoursPart = Math.floor(positiveMinutes / 60);
+    const minutesStr = minutesPart !== 0 ? String(minutesPart).padStart(2, '0') : '';
+    const hoursStr = String(hoursPart).padStart(2, '0');
+    return `${negative ? '-' : '+'}${hoursStr}${minutesStr ? `:${minutesStr}` : ''}`;
+}
+function getAbsoluteOffsetStringFromParts(hoursPart, minutesPart, secondsPart) {
+    const hoursStr = String(hoursPart).padStart(2, '0');
+    const minutesStr = minutesPart !== 0 || secondsPart !== 0
+        ? String(minutesPart).padStart(2, '0')
+        : '';
+    const secondsStr = secondsPart !== 0 ? String(secondsPart).padStart(2, '0') : '';
+    let result = hoursStr;
+    if (minutesStr) {
+        result += `:${minutesStr}`;
+        if (secondsStr) {
+            result += `:${secondsStr}`;
+        }
+    }
+    return result;
+}
+function getOffsetStringFromAbsoluteSeconds(absoluteOffsetInSeconds) {
+    const secondsPart = absoluteOffsetInSeconds % 60;
+    const minutes = Math.floor(absoluteOffsetInSeconds / 60);
+    const minutesPart = minutes % 60;
+    const hoursPart = Math.floor(minutes / 60);
+    return getAbsoluteOffsetStringFromParts(hoursPart, minutesPart, secondsPart);
+}
+function getOffsetStringFromSeconds(offsetInSeconds) {
+    const negative = offsetInSeconds < 0;
+    const absoluteOffsetInSeconds = negative ? -offsetInSeconds : offsetInSeconds;
+    const absoluteString = getOffsetStringFromAbsoluteSeconds(absoluteOffsetInSeconds);
+    return `${negative ? '-' : '+'}${absoluteString}`;
+}
 function getDuckDBTimeStringFromParts(hoursPart, minutesPart, secondsPart, microsecondsPart) {
     const hoursStr = String(hoursPart).padStart(2, '0');
     const minutesStr = String(minutesPart).padStart(2, '0');
@@ -110,23 +154,21 @@ function getDuckDBTimeStringFromMicroseconds(microseconds) {
     const positiveString = getDuckDBTimeStringFromPositiveMicroseconds(positiveMicroseconds);
     return negative ? `-${positiveString}` : positiveString;
 }
-function getDuckDBTimestampStringFromDaysAndMicroseconds(days, microsecondsInDay, timezone) {
+function getDuckDBTimestampStringFromDaysAndMicroseconds(days, microsecondsInDay, timezonePart) {
     // This conversion of BigInt to Number is safe, because the largest absolute value that `days` can has is 106751991,
     // which fits without loss of precision in a JS Number. (106751991 = (2^63-1) / MICROSECONDS_PER_DAY)
     const dateStr = getDuckDBDateStringFromDays(Number(days));
     const timeStr = getDuckDBTimeStringFromMicrosecondsInDay(microsecondsInDay);
-    const timezoneStr = timezone ? ` ${timezone}` : '';
-    return `${dateStr} ${timeStr}${timezoneStr}`;
+    return `${dateStr} ${timeStr}${timezonePart ?? ''}`;
 }
-function getDuckDBTimestampStringFromDaysAndNanoseconds(days, nanosecondsInDay, timezone) {
+function getDuckDBTimestampStringFromDaysAndNanoseconds(days, nanosecondsInDay) {
     // This conversion of BigInt to Number is safe, because the largest absolute value that `days` can has is 106751
     // which fits without loss of precision in a JS Number. (106751 = (2^63-1) / NANOSECONDS_PER_DAY)
     const dateStr = getDuckDBDateStringFromDays(Number(days));
     const timeStr = getDuckDBTimeStringFromNanosecondsInDay(nanosecondsInDay);
-    const timezoneStr = timezone ? ` ${timezone}` : '';
-    return `${dateStr} ${timeStr}${timezoneStr}`;
+    return `${dateStr} ${timeStr}`;
 }
-function getDuckDBTimestampStringFromMicroseconds(microseconds, timezone) {
+function getDuckDBTimestampStringFromMicroseconds(microseconds, timezoneOffsetInMinutes) {
     // Note that -infinity and infinity are only representable in TIMESTAMP (and TIMESTAMPTZ), not the other timestamp
     // variants. This is by-design and matches DuckDB.
     if (microseconds === NEGATIVE_INFINITY_TIMESTAMP) {
@@ -135,28 +177,34 @@ function getDuckDBTimestampStringFromMicroseconds(microseconds, timezone) {
     if (microseconds === POSITIVE_INFINITY_TIMESTAMP) {
         return 'infinity';
     }
-    let days = microseconds / MICROSECONDS_PER_DAY;
-    let microsecondsPart = microseconds % MICROSECONDS_PER_DAY;
+    const offsetMicroseconds = timezoneOffsetInMinutes !== undefined
+        ? microseconds +
+            BigInt(timezoneOffsetInMinutes) *
+                MICROSECONDS_PER_SECOND *
+                SECONDS_PER_MINUTE
+        : microseconds;
+    let days = offsetMicroseconds / MICROSECONDS_PER_DAY;
+    let microsecondsPart = offsetMicroseconds % MICROSECONDS_PER_DAY;
     if (microsecondsPart < 0) {
         days--;
         microsecondsPart += MICROSECONDS_PER_DAY;
     }
-    return getDuckDBTimestampStringFromDaysAndMicroseconds(days, microsecondsPart, timezone);
+    return getDuckDBTimestampStringFromDaysAndMicroseconds(days, microsecondsPart, getTimezoneOffsetString(timezoneOffsetInMinutes));
 }
-function getDuckDBTimestampStringFromSeconds(seconds, timezone) {
-    return getDuckDBTimestampStringFromMicroseconds(seconds * MICROSECONDS_PER_SECOND, timezone);
+function getDuckDBTimestampStringFromSeconds(seconds) {
+    return getDuckDBTimestampStringFromMicroseconds(seconds * MICROSECONDS_PER_SECOND);
 }
-function getDuckDBTimestampStringFromMilliseconds(milliseconds, timezone) {
-    return getDuckDBTimestampStringFromMicroseconds(milliseconds * MICROSECONDS_PER_MILLISECOND, timezone);
+function getDuckDBTimestampStringFromMilliseconds(milliseconds) {
+    return getDuckDBTimestampStringFromMicroseconds(milliseconds * MICROSECONDS_PER_MILLISECOND);
 }
-function getDuckDBTimestampStringFromNanoseconds(nanoseconds, timezone) {
+function getDuckDBTimestampStringFromNanoseconds(nanoseconds) {
     let days = nanoseconds / NANOSECONDS_PER_DAY;
     let nanosecondsPart = nanoseconds % NANOSECONDS_PER_DAY;
     if (nanosecondsPart < 0) {
         days--;
         nanosecondsPart += NANOSECONDS_PER_DAY;
     }
-    return getDuckDBTimestampStringFromDaysAndNanoseconds(days, nanosecondsPart, timezone);
+    return getDuckDBTimestampStringFromDaysAndNanoseconds(days, nanosecondsPart);
 }
 // Assumes baseUnit can be pluralized by adding an 's'.
 function numberAndUnit(value, baseUnit) {

package/lib/convertColumnsFromChunks.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+export declare function convertColumnsFromChunks<T>(chunks: readonly DuckDBDataChunk[], converter: DuckDBValueConverter<T>): T[][];

package/lib/convertColumnsFromChunks.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertColumnsFromChunks = convertColumnsFromChunks;
+function convertColumnsFromChunks(chunks, converter) {
+    if (chunks.length === 0) {
+        return [];
+    }
+    const convertedColumns = chunks[0].convertColumns(converter);
+    for (let chunkIndex = 1; chunkIndex < chunks.length; chunkIndex++) {
+        for (let columnIndex = 0; columnIndex < convertedColumns.length; columnIndex++) {
+            const chunk = chunks[chunkIndex];
+            chunk.visitColumnValues(columnIndex, (value, _rowIndex, _columnIndex, type) => convertedColumns[columnIndex].push(converter.convertValue(value, type)));
+        }
+    }
+    return convertedColumns;
+}

package/lib/convertColumnsObjectFromChunks.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+export declare function convertColumnsObjectFromChunks<T>(chunks: readonly DuckDBDataChunk[], columnNames: readonly string[], converter: DuckDBValueConverter<T>): Record<string, T[]>;

package/lib/convertColumnsObjectFromChunks.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertColumnsObjectFromChunks = convertColumnsObjectFromChunks;
+function convertColumnsObjectFromChunks(chunks, columnNames, converter) {
+    const convertedColumnsObject = {};
+    for (const columnName of columnNames) {
+        convertedColumnsObject[columnName] = [];
+    }
+    if (chunks.length === 0) {
+        return convertedColumnsObject;
+    }
+    const columnCount = chunks[0].columnCount;
+    for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            chunks[chunkIndex].visitColumnValues(columnIndex, (value, _rowIndex, _columnIndex, type) => convertedColumnsObject[columnNames[columnIndex]].push(converter.convertValue(value, type)));
+        }
+    }
+    return convertedColumnsObject;
+}

package/lib/convertRowObjectsFromChunks.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+export declare function convertRowObjectsFromChunks<T>(chunks: readonly DuckDBDataChunk[], columnNames: readonly string[], converter: DuckDBValueConverter<T>): Record<string, T>[];

package/lib/convertRowObjectsFromChunks.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRowObjectsFromChunks = convertRowObjectsFromChunks;
+function convertRowObjectsFromChunks(chunks, columnNames, converter) {
+    const rowObjects = [];
+    for (const chunk of chunks) {
+        const rowCount = chunk.rowCount;
+        for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+            const rowObject = {};
+            chunk.visitRowValues(rowIndex, (value, _rowIndex, columnIndex, type) => {
+                rowObject[columnNames[columnIndex]] = converter.convertValue(value, type);
+            });
+            rowObjects.push(rowObject);
+        }
+    }
+    return rowObjects;
+}

package/lib/convertRowsFromChunks.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+export declare function convertRowsFromChunks<T>(chunks: readonly DuckDBDataChunk[], converter: DuckDBValueConverter<T>): T[][];

package/lib/convertRowsFromChunks.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRowsFromChunks = convertRowsFromChunks;
+function convertRowsFromChunks(chunks, converter) {
+    const rows = [];
+    for (const chunk of chunks) {
+        const rowCount = chunk.rowCount;
+        for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+            rows.push(chunk.convertRowValues(rowIndex, converter));
+        }
+    }
+    return rows;
+}

package/lib/createValue.js

@@ -116,11 +116,17 @@ function createValue(type, input) {
             throw new Error(`not yet implemented for ENUM`); // TODO: implement when available in 1.2.0
         case DuckDBTypeId_1.DuckDBTypeId.LIST:
             if (input instanceof values_1.DuckDBListValue) {
+                if (type.valueType.typeId === DuckDBTypeId_1.DuckDBTypeId.ANY) {
+                    throw new Error('Cannot create lists with item type of ANY. Specify a specific type.');
+                }
                 return node_bindings_1.default.create_list_value(type.valueType.toLogicalType().logical_type, input.items.map((item) => createValue(type.valueType, item)));
             }
             throw new Error(`input is not a DuckDBListValue`);
         case DuckDBTypeId_1.DuckDBTypeId.STRUCT:
             if (input instanceof values_1.DuckDBStructValue) {
+                if (type.entryTypes.find((type) => type.typeId === DuckDBTypeId_1.DuckDBTypeId.ANY)) {
+                    throw new Error('Cannot create structs with an entry type of ANY. Specify a specific type.');
+                }
                 return node_bindings_1.default.create_struct_value(type.toLogicalType().logical_type, Object.values(input.entries).map((value, i) => createValue(type.entryTypes[i], value)));
             }
             throw new Error(`input is not a DuckDBStructValue`);
@@ -128,6 +134,9 @@ function createValue(type, input) {
             throw new Error(`not yet implemented for MAP`); // TODO: implement when available, hopefully in 1.2.0
         case DuckDBTypeId_1.DuckDBTypeId.ARRAY:
             if (input instanceof values_1.DuckDBArrayValue) {
+                if (type.valueType.typeId === DuckDBTypeId_1.DuckDBTypeId.ANY) {
+                    throw new Error('Cannot create arrays with item type of ANY. Specify a specific type.');
+                }
                 return node_bindings_1.default.create_array_value(type.valueType.toLogicalType().logical_type, input.items.map((item) => createValue(type.valueType, item)));
             }
             throw new Error(`input is not a DuckDBArrayValue`);
@@ -148,7 +157,7 @@ function createValue(type, input) {
             }
             throw new Error(`input is not a DuckDBTimestampTZValue`);
         case DuckDBTypeId_1.DuckDBTypeId.ANY:
-            throw new Error(`cannot create values of type ANY`);
+            throw new Error(`Cannot create values of type ANY. Specify a specific type.`);
         case DuckDBTypeId_1.DuckDBTypeId.VARINT:
             throw new Error(`not yet implemented for VARINT`); // TODO: implement when available in 1.2.0
         case DuckDBTypeId_1.DuckDBTypeId.SQLNULL:

package/lib/getColumnsFromChunks.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValue } from './values';
+export declare function getColumnsFromChunks(chunks: readonly DuckDBDataChunk[]): DuckDBValue[][];

package/lib/getColumnsFromChunks.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColumnsFromChunks = getColumnsFromChunks;
+function getColumnsFromChunks(chunks) {
+    const columns = [];
+    if (chunks.length === 0) {
+        return columns;
+    }
+    chunks[0].visitColumns((column) => columns.push(column));
+    for (let chunkIndex = 1; chunkIndex < chunks.length; chunkIndex++) {
+        for (let columnIndex = 0; columnIndex < columns.length; columnIndex++) {
+            chunks[chunkIndex].visitColumnValues(columnIndex, (value) => columns[columnIndex].push(value));
+        }
+    }
+    return columns;
+}

package/lib/getColumnsObjectFromChunks.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValue } from './values';
+export declare function getColumnsObjectFromChunks(chunks: readonly DuckDBDataChunk[], columnNames: readonly string[]): Record<string, DuckDBValue[]>;

package/lib/getColumnsObjectFromChunks.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColumnsObjectFromChunks = getColumnsObjectFromChunks;
+function getColumnsObjectFromChunks(chunks, columnNames) {
+    const columnsObject = {};
+    for (const columnName of columnNames) {
+        columnsObject[columnName] = [];
+    }
+    if (chunks.length === 0) {
+        return columnsObject;
+    }
+    const columnCount = chunks[0].columnCount;
+    for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            chunks[chunkIndex].visitColumnValues(columnIndex, (value) => columnsObject[columnNames[columnIndex]].push(value));
+        }
+    }
+    return columnsObject;
+}

package/lib/getRowObjectsFromChunks.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValue } from './values';
+export declare function getRowObjectsFromChunks(chunks: readonly DuckDBDataChunk[], columnNames: readonly string[]): Record<string, DuckDBValue>[];

package/lib/getRowObjectsFromChunks.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRowObjectsFromChunks = getRowObjectsFromChunks;
+function getRowObjectsFromChunks(chunks, columnNames) {
+    const rowObjects = [];
+    for (const chunk of chunks) {
+        const rowCount = chunk.rowCount;
+        for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+            const rowObject = {};
+            chunk.visitRowValues(rowIndex, (value, _, columnIndex) => {
+                rowObject[columnNames[columnIndex]] = value;
+            });
+            rowObjects.push(rowObject);
+        }
+    }
+    return rowObjects;
+}

package/lib/getRowsFromChunks.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValue } from './values';
+export declare function getRowsFromChunks(chunks: readonly DuckDBDataChunk[]): DuckDBValue[][];

package/lib/getRowsFromChunks.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRowsFromChunks = getRowsFromChunks;
+function getRowsFromChunks(chunks) {
+    const rows = [];
+    for (const chunk of chunks) {
+        chunk.visitRows((row) => rows.push(row));
+    }
+    return rows;
+}

package/lib/index.d.ts

@@ -11,6 +11,8 @@ export * from './DuckDBPreparedStatement';
 export * from './DuckDBResult';
 export * from './DuckDBType';
 export * from './DuckDBTypeId';
+export * from './DuckDBValueConverter';
+export * from './DuckDBValueToJsonConverter';
 export * from './DuckDBVector';
 export * from './configurationOptionDescriptions';
 export * from './enums';

package/lib/index.js

@@ -32,6 +32,8 @@ __exportStar(require("./DuckDBPreparedStatement"), exports);
 __exportStar(require("./DuckDBResult"), exports);
 __exportStar(require("./DuckDBType"), exports);
 __exportStar(require("./DuckDBTypeId"), exports);
+__exportStar(require("./DuckDBValueConverter"), exports);
+__exportStar(require("./DuckDBValueToJsonConverter"), exports);
 __exportStar(require("./DuckDBVector"), exports);
 __exportStar(require("./configurationOptionDescriptions"), exports);
 __exportStar(require("./enums"), exports);

package/lib/typeForValue.js

@@ -12,7 +12,12 @@ function typeForValue(value) {
             case 'boolean':
                 return DuckDBType_1.BOOLEAN;
             case 'number':
-                return DuckDBType_1.DOUBLE;
+                if (Math.round(value) === value) {
+                    return DuckDBType_1.INTEGER;
+                }
+                else {
+                    return DuckDBType_1.DOUBLE;
+                }
             case 'bigint':
                 return DuckDBType_1.HUGEINT;
             case 'string':

package/lib/values/DuckDBTimeTZValue.d.ts

@@ -2,16 +2,16 @@ import { TimeTZ, TimeTZParts } from '@duckdb/node-bindings';
 export type { TimeTZParts };
 export declare class DuckDBTimeTZValue implements TimeTZ {
     /**
-    * 40 bits for micros, then 24 bits for encoded offset in seconds.
-    *
-    * Max absolute unencoded offset = 15:59:59 = 60 * (60 * 15 + 59) + 59 = 57599.
-    *
-    * Encoded offset is unencoded offset inverted then shifted (by +57599) to unsigned.
-    *
-    * Max unencoded offset = 57599 -> -57599 -> 0 encoded.
-    *
-    * Min unencoded offset = -57599 -> 57599 -> 115198 encoded.
-    */
+     * 40 bits for micros, then 24 bits for encoded offset in seconds.
+     *
+     * Max absolute unencoded offset = 15:59:59 = 60 * (60 * 15 + 59) + 59 = 57599.
+     *
+     * Encoded offset is unencoded offset inverted then shifted (by +57599) to unsigned.
+     *
+     * Max unencoded offset = 57599 -> -57599 -> 0 encoded.
+     *
+     * Min unencoded offset = -57599 -> 57599 -> 115198 encoded.
+     */
     readonly bits: bigint;
     /** Ranges from 0 to 86400000000 (= 24 * 60 * 60 * 1000 * 1000) */
     readonly micros: bigint;

package/lib/values/DuckDBTimeTZValue.js

@@ -9,16 +9,16 @@ const node_bindings_1 = __importDefault(require("@duckdb/node-bindings"));
 const dateTimeStringConversion_1 = require("../conversion/dateTimeStringConversion");
 class DuckDBTimeTZValue {
     /**
-    * 40 bits for micros, then 24 bits for encoded offset in seconds.
-    *
-    * Max absolute unencoded offset = 15:59:59 = 60 * (60 * 15 + 59) + 59 = 57599.
-    *
-    * Encoded offset is unencoded offset inverted then shifted (by +57599) to unsigned.
-    *
-    * Max unencoded offset = 57599 -> -57599 -> 0 encoded.
-    *
-    * Min unencoded offset = -57599 -> 57599 -> 115198 encoded.
-    */
+     * 40 bits for micros, then 24 bits for encoded offset in seconds.
+     *
+     * Max absolute unencoded offset = 15:59:59 = 60 * (60 * 15 + 59) + 59 = 57599.
+     *
+     * Encoded offset is unencoded offset inverted then shifted (by +57599) to unsigned.
+     *
+     * Max unencoded offset = 57599 -> -57599 -> 0 encoded.
+     *
+     * Min unencoded offset = -57599 -> 57599 -> 115198 encoded.
+     */
     bits;
     /** Ranges from 0 to 86400000000 (= 24 * 60 * 60 * 1000 * 1000) */
     micros;
@@ -30,8 +30,7 @@ class DuckDBTimeTZValue {
         this.offset = offset;
     }
     toString() {
-        // TODO: display offset
-        return (0, dateTimeStringConversion_1.getDuckDBTimeStringFromMicrosecondsInDay)(this.micros);
+        return `${(0, dateTimeStringConversion_1.getDuckDBTimeStringFromMicrosecondsInDay)(this.micros)}${(0, dateTimeStringConversion_1.getOffsetStringFromSeconds)(this.offset)}`;
     }
     toParts() {
         return node_bindings_1.default.from_time_tz(this);
@@ -44,12 +43,14 @@ class DuckDBTimeTZValue {
     static MinMicros = 0n;
     static fromBits(bits) {
         const micros = BigInt.asUintN(DuckDBTimeTZValue.TimeBits, bits >> BigInt(DuckDBTimeTZValue.OffsetBits));
-        const offset = DuckDBTimeTZValue.MaxOffset - Number(BigInt.asUintN(DuckDBTimeTZValue.OffsetBits, bits));
+        const offset = DuckDBTimeTZValue.MaxOffset -
+            Number(BigInt.asUintN(DuckDBTimeTZValue.OffsetBits, bits));
         return new DuckDBTimeTZValue(bits, micros, offset);
     }
     static fromMicrosAndOffset(micros, offset) {
-        const bits = BigInt.asUintN(DuckDBTimeTZValue.TimeBits, micros) << BigInt(DuckDBTimeTZValue.OffsetBits)
-            | BigInt.asUintN(DuckDBTimeTZValue.OffsetBits, BigInt(DuckDBTimeTZValue.MaxOffset - offset));
+        const bits = (BigInt.asUintN(DuckDBTimeTZValue.TimeBits, micros) <<
+            BigInt(DuckDBTimeTZValue.OffsetBits)) |
+            BigInt.asUintN(DuckDBTimeTZValue.OffsetBits, BigInt(DuckDBTimeTZValue.MaxOffset - offset));
         return new DuckDBTimeTZValue(bits, micros, offset);
     }
     static fromParts(parts) {

package/lib/values/DuckDBTimestampMillisecondsValue.d.ts

@@ -1,9 +1,13 @@
-export declare class DuckDBTimestampMillisecondsValue {
-    readonly milliseconds: bigint;
-    constructor(milliseconds: bigint);
+import { TimestampMilliseconds } from '@duckdb/node-bindings';
+export declare class DuckDBTimestampMillisecondsValue implements TimestampMilliseconds {
+    readonly millis: bigint;
+    constructor(millis: bigint);
+    get isFinite(): boolean;
     toString(): string;
     static readonly Epoch: DuckDBTimestampMillisecondsValue;
     static readonly Max: DuckDBTimestampMillisecondsValue;
     static readonly Min: DuckDBTimestampMillisecondsValue;
+    static readonly PosInf: DuckDBTimestampMillisecondsValue;
+    static readonly NegInf: DuckDBTimestampMillisecondsValue;
 }
-export declare function timestampMillisValue(milliseconds: bigint): DuckDBTimestampMillisecondsValue;
+export declare function timestampMillisValue(millis: bigint): DuckDBTimestampMillisecondsValue;