@duckdb/node-api 1.2.1-alpha.16 → 1.2.2-alpha.18

package/lib/DuckDBValueConverters.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsupportedConverter = unsupportedConverter;
+exports.nullConverter = nullConverter;
+exports.booleanFromValue = booleanFromValue;
+exports.numberFromValue = numberFromValue;
+exports.jsonNumberFromValue = jsonNumberFromValue;
+exports.bigintFromBigIntValue = bigintFromBigIntValue;
+exports.stringFromValue = stringFromValue;
+exports.bytesFromBlobValue = bytesFromBlobValue;
+exports.bytesFromBitValue = bytesFromBitValue;
+exports.dateFromDateValue = dateFromDateValue;
+exports.bigintFromTimeValue = bigintFromTimeValue;
+exports.dateFromTimestampValue = dateFromTimestampValue;
+exports.dateFromTimestampSecondsValue = dateFromTimestampSecondsValue;
+exports.dateFromTimestampMillisecondsValue = dateFromTimestampMillisecondsValue;
+exports.dateFromTimestampNanosecondsValue = dateFromTimestampNanosecondsValue;
+exports.objectFromTimeTZValue = objectFromTimeTZValue;
+exports.dateFromTimestampTZValue = dateFromTimestampTZValue;
+exports.objectFromIntervalValue = objectFromIntervalValue;
+exports.jsonObjectFromIntervalValue = jsonObjectFromIntervalValue;
+exports.doubleFromDecimalValue = doubleFromDecimalValue;
+exports.arrayFromListValue = arrayFromListValue;
+exports.objectFromStructValue = objectFromStructValue;
+exports.objectArrayFromMapValue = objectArrayFromMapValue;
+exports.arrayFromArrayValue = arrayFromArrayValue;
+exports.objectFromUnionValue = objectFromUnionValue;
+const DuckDBType_1 = require("./DuckDBType");
+const values_1 = require("./values");
+const MIN_DATE_DAYS = -100000000;
+const MAX_DATE_DAYS = 100000000;
+//                      -8640000000000
+const MIN_DATE_MILLIS = -8640000000000000;
+const MAX_DATE_MILLIS = 8640000000000000;
+const MILLS_PER_DAY = 24 * 60 * 60 * 1000;
+function unsupportedConverter(_, type) {
+    throw new Error(`Unsupported type: ${type}`);
+}
+function nullConverter(_) {
+    return null;
+}
+function booleanFromValue(value) {
+    return Boolean(value);
+}
+function numberFromValue(value) {
+    return Number(value);
+}
+function jsonNumberFromValue(value) {
+    if (Number.isFinite(value)) {
+        return Number(value);
+    }
+    return String(value);
+}
+function bigintFromBigIntValue(value, type) {
+    if (typeof value === 'bigint') {
+        return value;
+    }
+    throw new Error(`Expected bigint value for type ${type}`);
+}
+function stringFromValue(value) {
+    return String(value);
+}
+function bytesFromBlobValue(value) {
+    if (value instanceof values_1.DuckDBBlobValue) {
+        return value.bytes;
+    }
+    throw new Error(`Expected DuckDBBlobValue`);
+}
+function bytesFromBitValue(value) {
+    if (value instanceof values_1.DuckDBBitValue) {
+        return value.data;
+    }
+    throw new Error(`Expected DuckDBBitValue`);
+}
+function dateFromDateValue(value) {
+    if (value instanceof values_1.DuckDBDateValue) {
+        if (MIN_DATE_DAYS <= value.days && value.days <= MAX_DATE_DAYS) {
+            return new Date(value.days * MILLS_PER_DAY);
+        }
+        throw new Error(`DATE value out of range for JS Date: ${value.days} days`);
+    }
+    throw new Error(`Expected DuckDBDateValue`);
+}
+function bigintFromTimeValue(value) {
+    if (value instanceof values_1.DuckDBTimeValue) {
+        return value.micros;
+    }
+    throw new Error(`Expected DuckDBTimeValue`);
+}
+function dateFromTimestampValue(value) {
+    if (value instanceof values_1.DuckDBTimestampValue) {
+        const millis = value.micros / 1000n;
+        if (MIN_DATE_MILLIS <= millis && millis <= MAX_DATE_MILLIS) {
+            return new Date(Number(millis));
+        }
+        throw new Error(`TIMESTAMP value out of range for JS Date: ${value.micros} micros`);
+    }
+    throw new Error(`Expected DuckDBTimestampValue`);
+}
+function dateFromTimestampSecondsValue(value) {
+    if (value instanceof values_1.DuckDBTimestampSecondsValue) {
+        const millis = value.seconds * 1000n;
+        if (MIN_DATE_MILLIS <= millis && millis <= MAX_DATE_MILLIS) {
+            return new Date(Number(millis));
+        }
+        throw new Error(`TIMESTAMP_S value out of range for JS Date: ${value.seconds} seconds`);
+    }
+    throw new Error(`Expected DuckDBTimestampSecondsValue`);
+}
+function dateFromTimestampMillisecondsValue(value) {
+    if (value instanceof values_1.DuckDBTimestampMillisecondsValue) {
+        const millis = value.millis;
+        if (MIN_DATE_MILLIS <= millis && millis <= MAX_DATE_MILLIS) {
+            return new Date(Number(millis));
+        }
+        throw new Error(`TIMESTAMP_MS value out of range for JS Date: ${value.millis} millis`);
+    }
+    throw new Error(`Expected DuckDBTimestampMillisecondsValue`);
+}
+function dateFromTimestampNanosecondsValue(value) {
+    if (value instanceof values_1.DuckDBTimestampNanosecondsValue) {
+        const millis = value.nanos / 1000000n;
+        if (MIN_DATE_MILLIS <= millis && millis <= MAX_DATE_MILLIS) {
+            return new Date(Number(millis));
+        }
+        throw new Error(`TIMESTAMP_NS value out of range for JS Date: ${value.nanos} nanos`);
+    }
+    throw new Error(`Expected DuckDBTimestampNanosecondsValue`);
+}
+function objectFromTimeTZValue(value) {
+    if (value instanceof values_1.DuckDBTimeTZValue) {
+        return {
+            micros: value.micros,
+            offset: value.offset,
+        };
+    }
+    throw new Error(`Expected DuckDBTimeTZValue`);
+}
+function dateFromTimestampTZValue(value) {
+    if (value instanceof values_1.DuckDBTimestampTZValue) {
+        const millis = value.micros / 1000n;
+        if (MIN_DATE_MILLIS <= millis && millis <= MAX_DATE_MILLIS) {
+            return new Date(Number(millis));
+        }
+        throw new Error(`TIMESTAMPTZ value out of range for JS Date: ${value.micros} micros`);
+    }
+    throw new Error(`Expected DuckDBTimestampTZValue`);
+}
+function objectFromIntervalValue(value) {
+    if (value instanceof values_1.DuckDBIntervalValue) {
+        return {
+            months: value.months,
+            days: value.days,
+            micros: value.micros,
+        };
+    }
+    throw new Error(`Expected DuckDBIntervalValue`);
+}
+function jsonObjectFromIntervalValue(value) {
+    if (value instanceof values_1.DuckDBIntervalValue) {
+        return {
+            months: value.months,
+            days: value.days,
+            micros: String(value.micros),
+        };
+    }
+    throw new Error(`Expected DuckDBIntervalValue`);
+}
+function doubleFromDecimalValue(value) {
+    if (value instanceof values_1.DuckDBDecimalValue) {
+        return value.toDouble();
+    }
+    throw new Error(`Expected DuckDBDecimalValue`);
+}
+function arrayFromListValue(value, type, converter) {
+    if (value instanceof values_1.DuckDBListValue && type instanceof DuckDBType_1.DuckDBListType) {
+        return value.items.map((v) => converter(v, type.valueType, converter));
+    }
+    throw new Error(`Expected DuckDBListValue and DuckDBListType`);
+}
+function objectFromStructValue(value, type, converter) {
+    if (value instanceof values_1.DuckDBStructValue && type instanceof DuckDBType_1.DuckDBStructType) {
+        const result = {};
+        for (const key in value.entries) {
+            result[key] = converter(value.entries[key], type.typeForEntry(key), converter);
+        }
+        return result;
+    }
+    throw new Error(`Expected DuckDBStructValue and DuckDBStructType`);
+}
+function objectArrayFromMapValue(value, type, converter) {
+    if (value instanceof values_1.DuckDBMapValue && type instanceof DuckDBType_1.DuckDBMapType) {
+        return value.entries.map((entry) => ({
+            key: converter(entry.key, type.keyType, converter),
+            value: converter(entry.value, type.valueType, converter),
+        }));
+    }
+    throw new Error(`Expected DuckDBMapValue and DuckDBMapType`);
+}
+function arrayFromArrayValue(value, type, converter) {
+    if (value instanceof values_1.DuckDBArrayValue && type instanceof DuckDBType_1.DuckDBArrayType) {
+        return value.items.map((v) => converter(v, type.valueType, converter));
+    }
+    throw new Error(`Expected DuckDBArrayValue and DuckDBArrayType`);
+}
+function objectFromUnionValue(value, type, converter) {
+    if (value instanceof values_1.DuckDBUnionValue && type instanceof DuckDBType_1.DuckDBUnionType) {
+        return {
+            tag: value.tag,
+            value: converter(value.value, type.memberTypeForTag(value.tag), converter),
+        };
+    }
+    throw new Error(`Expected DuckDBUnionValue and DuckDBUnionType`);
+}

package/lib/JS.d.ts

@@ -0,0 +1,3 @@
+export type JS = null | boolean | number | bigint | string | Uint8Array | Date | JS[] | {
+    [key: string]: JS;
+};

package/lib/JS.js

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

package/lib/JSDuckDBValueConverter.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+import { JS } from './JS';
+export declare const JSDuckDBValueConverter: DuckDBValueConverter<JS>;

package/lib/JSDuckDBValueConverter.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSDuckDBValueConverter = void 0;
+const createDuckDBValueConverter_1 = require("./createDuckDBValueConverter");
+const DuckDBTypeId_1 = require("./DuckDBTypeId");
+const DuckDBValueConverters_1 = require("./DuckDBValueConverters");
+const JSConvertersByTypeId = {
+    [DuckDBTypeId_1.DuckDBTypeId.INVALID]: DuckDBValueConverters_1.unsupportedConverter,
+    [DuckDBTypeId_1.DuckDBTypeId.BOOLEAN]: DuckDBValueConverters_1.booleanFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TINYINT]: DuckDBValueConverters_1.numberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.SMALLINT]: DuckDBValueConverters_1.numberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.INTEGER]: DuckDBValueConverters_1.numberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.BIGINT]: DuckDBValueConverters_1.bigintFromBigIntValue,
+    [DuckDBTypeId_1.DuckDBTypeId.UTINYINT]: DuckDBValueConverters_1.numberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.USMALLINT]: DuckDBValueConverters_1.numberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.UINTEGER]: DuckDBValueConverters_1.numberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.UBIGINT]: DuckDBValueConverters_1.bigintFromBigIntValue,
+    [DuckDBTypeId_1.DuckDBTypeId.FLOAT]: DuckDBValueConverters_1.numberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.DOUBLE]: DuckDBValueConverters_1.numberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP]: DuckDBValueConverters_1.dateFromTimestampValue,
+    [DuckDBTypeId_1.DuckDBTypeId.DATE]: DuckDBValueConverters_1.dateFromDateValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TIME]: DuckDBValueConverters_1.bigintFromTimeValue,
+    [DuckDBTypeId_1.DuckDBTypeId.INTERVAL]: DuckDBValueConverters_1.objectFromIntervalValue,
+    [DuckDBTypeId_1.DuckDBTypeId.HUGEINT]: DuckDBValueConverters_1.bigintFromBigIntValue,
+    [DuckDBTypeId_1.DuckDBTypeId.UHUGEINT]: DuckDBValueConverters_1.bigintFromBigIntValue,
+    [DuckDBTypeId_1.DuckDBTypeId.VARCHAR]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.BLOB]: DuckDBValueConverters_1.bytesFromBlobValue,
+    [DuckDBTypeId_1.DuckDBTypeId.DECIMAL]: DuckDBValueConverters_1.doubleFromDecimalValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_S]: DuckDBValueConverters_1.dateFromTimestampSecondsValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_MS]: DuckDBValueConverters_1.dateFromTimestampMillisecondsValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_NS]: DuckDBValueConverters_1.dateFromTimestampNanosecondsValue,
+    [DuckDBTypeId_1.DuckDBTypeId.ENUM]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.LIST]: DuckDBValueConverters_1.arrayFromListValue,
+    [DuckDBTypeId_1.DuckDBTypeId.STRUCT]: DuckDBValueConverters_1.objectFromStructValue,
+    [DuckDBTypeId_1.DuckDBTypeId.MAP]: DuckDBValueConverters_1.objectArrayFromMapValue,
+    [DuckDBTypeId_1.DuckDBTypeId.ARRAY]: DuckDBValueConverters_1.arrayFromArrayValue,
+    [DuckDBTypeId_1.DuckDBTypeId.UUID]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.UNION]: DuckDBValueConverters_1.objectFromUnionValue,
+    [DuckDBTypeId_1.DuckDBTypeId.BIT]: DuckDBValueConverters_1.bytesFromBitValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TIME_TZ]: DuckDBValueConverters_1.objectFromTimeTZValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_TZ]: DuckDBValueConverters_1.dateFromTimestampTZValue,
+    [DuckDBTypeId_1.DuckDBTypeId.ANY]: DuckDBValueConverters_1.unsupportedConverter,
+    [DuckDBTypeId_1.DuckDBTypeId.VARINT]: DuckDBValueConverters_1.bigintFromBigIntValue,
+    [DuckDBTypeId_1.DuckDBTypeId.SQLNULL]: DuckDBValueConverters_1.nullConverter,
+};
+exports.JSDuckDBValueConverter = (0, createDuckDBValueConverter_1.createDuckDBValueConverter)(JSConvertersByTypeId);

package/lib/Json.d.ts

@@ -0,0 +1,3 @@
+export type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};

package/lib/Json.js

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

package/lib/JsonDuckDBValueConverter.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+import { Json } from './Json';
+export declare const JsonDuckDBValueConverter: DuckDBValueConverter<Json>;

package/lib/JsonDuckDBValueConverter.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonDuckDBValueConverter = void 0;
+const createDuckDBValueConverter_1 = require("./createDuckDBValueConverter");
+const DuckDBTypeId_1 = require("./DuckDBTypeId");
+const DuckDBValueConverters_1 = require("./DuckDBValueConverters");
+const JsonConvertersByTypeId = {
+    [DuckDBTypeId_1.DuckDBTypeId.INVALID]: DuckDBValueConverters_1.unsupportedConverter,
+    [DuckDBTypeId_1.DuckDBTypeId.BOOLEAN]: DuckDBValueConverters_1.booleanFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TINYINT]: DuckDBValueConverters_1.numberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.SMALLINT]: DuckDBValueConverters_1.numberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.INTEGER]: DuckDBValueConverters_1.numberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.BIGINT]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.UTINYINT]: DuckDBValueConverters_1.numberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.USMALLINT]: DuckDBValueConverters_1.numberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.UINTEGER]: DuckDBValueConverters_1.numberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.UBIGINT]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.FLOAT]: DuckDBValueConverters_1.jsonNumberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.DOUBLE]: DuckDBValueConverters_1.jsonNumberFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.DATE]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TIME]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.INTERVAL]: DuckDBValueConverters_1.jsonObjectFromIntervalValue,
+    [DuckDBTypeId_1.DuckDBTypeId.HUGEINT]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.UHUGEINT]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.VARCHAR]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.BLOB]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.DECIMAL]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_S]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_MS]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_NS]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.ENUM]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.LIST]: DuckDBValueConverters_1.arrayFromListValue,
+    [DuckDBTypeId_1.DuckDBTypeId.STRUCT]: DuckDBValueConverters_1.objectFromStructValue,
+    [DuckDBTypeId_1.DuckDBTypeId.MAP]: DuckDBValueConverters_1.objectArrayFromMapValue,
+    [DuckDBTypeId_1.DuckDBTypeId.ARRAY]: DuckDBValueConverters_1.arrayFromArrayValue,
+    [DuckDBTypeId_1.DuckDBTypeId.UUID]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.UNION]: DuckDBValueConverters_1.objectFromUnionValue,
+    [DuckDBTypeId_1.DuckDBTypeId.BIT]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TIME_TZ]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_TZ]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.ANY]: DuckDBValueConverters_1.unsupportedConverter,
+    [DuckDBTypeId_1.DuckDBTypeId.VARINT]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.SQLNULL]: DuckDBValueConverters_1.nullConverter,
+};
+exports.JsonDuckDBValueConverter = (0, createDuckDBValueConverter_1.createDuckDBValueConverter)(JsonConvertersByTypeId);

package/lib/conversion/stringFromBlob.d.ts

@@ -1,2 +1,4 @@
 /** Matches BLOB-to-VARCHAR conversion behavior of DuckDB. */
 export declare function stringFromBlob(bytes: Uint8Array): string;
+export declare function stringFromBlobStringConcat(bytes: Uint8Array): string;
+export declare function stringFromBlobArrayJoin(bytes: Uint8Array): string;

package/lib/conversion/stringFromBlob.js

@@ -1,13 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stringFromBlob = stringFromBlob;
+exports.stringFromBlobStringConcat = stringFromBlobStringConcat;
+exports.stringFromBlobArrayJoin = stringFromBlobArrayJoin;
 /** Matches BLOB-to-VARCHAR conversion behavior of DuckDB. */
 function stringFromBlob(bytes) {
+    // String concatenation appears to be faster for this function at smaller sizes.
+    // Threshold of (2^16) experimentally determined on a MacBook Pro (M2 Max).
+    // See stringFromBlob.bench.ts.
+    if (bytes.length <= 65536) {
+        return stringFromBlobStringConcat(bytes);
+    }
+    return stringFromBlobArrayJoin(bytes);
+}
+function stringFromBlobStringConcat(bytes) {
+    let byteString = '';
+    for (const byte of bytes) {
+        if (byte <= 0x1f ||
+            byte === 0x22 /* double quote */ ||
+            byte === 0x27 /* single quote */ ||
+            byte >= 0x7f) {
+            byteString += `\\x${byte.toString(16).toUpperCase().padStart(2, '0')}`;
+        }
+        else {
+            byteString += String.fromCharCode(byte);
+        }
+    }
+    return byteString;
+}
+function stringFromBlobArrayJoin(bytes) {
     const byteStrings = [];
     for (const byte of bytes) {
         if (byte <= 0x1f ||
-            byte === 0x22 /* single quote */ ||
-            byte === 0x27 /* double quote */ ||
+            byte === 0x22 /* double quote */ ||
+            byte === 0x27 /* single quote */ ||
             byte >= 0x7f) {
             byteStrings.push(`\\x${byte.toString(16).toUpperCase().padStart(2, '0')}`);
         }

package/lib/convertColumnsFromChunks.d.ts

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

package/lib/convertColumnsFromChunks.js

@@ -9,7 +9,7 @@ function convertColumnsFromChunks(chunks, 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)));
+            chunk.visitColumnValues(columnIndex, (value, _rowIndex, _columnIndex, type) => convertedColumns[columnIndex].push(converter(value, type, converter)));
         }
     }
     return convertedColumns;

package/lib/convertColumnsObjectFromChunks.d.ts

@@ -1,3 +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[]>;
+export declare function convertColumnsObjectFromChunks<T>(chunks: readonly DuckDBDataChunk[], columnNames: readonly string[], converter: DuckDBValueConverter<T>): Record<string, (T | null)[]>;

package/lib/convertColumnsObjectFromChunks.js

@@ -12,7 +12,7 @@ function convertColumnsObjectFromChunks(chunks, columnNames, converter) {
     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)));
+            chunks[chunkIndex].visitColumnValues(columnIndex, (value, _rowIndex, _columnIndex, type) => convertedColumnsObject[columnNames[columnIndex]].push(converter(value, type, converter)));
         }
     }
     return convertedColumnsObject;

package/lib/convertRowObjectsFromChunks.d.ts

@@ -1,3 +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>[];
+export declare function convertRowObjectsFromChunks<T>(chunks: readonly DuckDBDataChunk[], columnNames: readonly string[], converter: DuckDBValueConverter<T>): Record<string, T | null>[];

package/lib/convertRowObjectsFromChunks.js

@@ -8,7 +8,7 @@ function convertRowObjectsFromChunks(chunks, columnNames, converter) {
         for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
             const rowObject = {};
             chunk.visitRowValues(rowIndex, (value, _rowIndex, columnIndex, type) => {
-                rowObject[columnNames[columnIndex]] = converter.convertValue(value, type);
+                rowObject[columnNames[columnIndex]] = converter(value, type, converter);
             });
             rowObjects.push(rowObject);
         }

package/lib/convertRowsFromChunks.d.ts

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

package/lib/createConfig.d.ts

@@ -0,0 +1,2 @@
+import duckdb from '@duckdb/node-bindings';
+export declare function createConfig(options?: Record<string, string>): duckdb.Config;

package/lib/createConfig.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfig = createConfig;
+const node_bindings_1 = __importDefault(require("@duckdb/node-bindings"));
+function createConfig(options) {
+    const config = node_bindings_1.default.create_config();
+    // Set the default duckdb_api value for the api. Can be overridden.
+    node_bindings_1.default.set_config(config, 'duckdb_api', 'node-neo-api');
+    if (options) {
+        for (const optionName in options) {
+            const optionValue = String(options[optionName]);
+            node_bindings_1.default.set_config(config, optionName, optionValue);
+        }
+    }
+    return config;
+}

package/lib/createDuckDBValueConverter.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBTypeId } from './DuckDBTypeId';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+export declare function createDuckDBValueConverter<T>(convertersByTypeId: Record<DuckDBTypeId, DuckDBValueConverter<T> | undefined>): DuckDBValueConverter<T>;

package/lib/createDuckDBValueConverter.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDuckDBValueConverter = createDuckDBValueConverter;
+function createDuckDBValueConverter(convertersByTypeId) {
+    return (value, type, converter) => {
+        if (value == null) {
+            return null;
+        }
+        const converterForTypeId = convertersByTypeId[type.typeId];
+        if (!converterForTypeId) {
+            throw new Error(`No converter for typeId: ${type.typeId}`);
+        }
+        return converterForTypeId(value, type, converter);
+    };
+}

package/lib/duckdb.d.ts

@@ -1,4 +1,6 @@
-export { hugeint_to_double, double_to_hugeint, uhugeint_to_double, double_to_uhugeint, } from '@duckdb/node-bindings';
+export { double_to_hugeint, double_to_uhugeint, hugeint_to_double, uhugeint_to_double } from '@duckdb/node-bindings';
+export * from './configurationOptionDescriptions';
+export * from './createDuckDBValueConverter';
 export * from './DuckDBAppender';
 export * from './DuckDBConnection';
 export * from './DuckDBDataChunk';
@@ -12,10 +14,13 @@ export * from './DuckDBResult';
 export * from './DuckDBType';
 export * from './DuckDBTypeId';
 export * from './DuckDBValueConverter';
-export * from './DuckDBValueToJsonConverter';
+export * from './DuckDBValueConverters';
 export * from './DuckDBVector';
-export * from './configurationOptionDescriptions';
 export * from './enums';
+export * from './JS';
+export * from './JSDuckDBValueConverter';
+export * from './Json';
+export * from './JsonDuckDBValueConverter';
 export * from './sql';
 export * from './values';
 export * from './version';

package/lib/duckdb.js

@@ -14,12 +14,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.double_to_uhugeint = exports.uhugeint_to_double = exports.double_to_hugeint = exports.hugeint_to_double = void 0;
+exports.uhugeint_to_double = exports.hugeint_to_double = exports.double_to_uhugeint = exports.double_to_hugeint = void 0;
 var node_bindings_1 = require("@duckdb/node-bindings");
-Object.defineProperty(exports, "hugeint_to_double", { enumerable: true, get: function () { return node_bindings_1.hugeint_to_double; } });
 Object.defineProperty(exports, "double_to_hugeint", { enumerable: true, get: function () { return node_bindings_1.double_to_hugeint; } });
-Object.defineProperty(exports, "uhugeint_to_double", { enumerable: true, get: function () { return node_bindings_1.uhugeint_to_double; } });
 Object.defineProperty(exports, "double_to_uhugeint", { enumerable: true, get: function () { return node_bindings_1.double_to_uhugeint; } });
+Object.defineProperty(exports, "hugeint_to_double", { enumerable: true, get: function () { return node_bindings_1.hugeint_to_double; } });
+Object.defineProperty(exports, "uhugeint_to_double", { enumerable: true, get: function () { return node_bindings_1.uhugeint_to_double; } });
+__exportStar(require("./configurationOptionDescriptions"), exports);
+__exportStar(require("./createDuckDBValueConverter"), exports);
 __exportStar(require("./DuckDBAppender"), exports);
 __exportStar(require("./DuckDBConnection"), exports);
 __exportStar(require("./DuckDBDataChunk"), exports);
@@ -33,10 +35,13 @@ __exportStar(require("./DuckDBResult"), exports);
 __exportStar(require("./DuckDBType"), exports);
 __exportStar(require("./DuckDBTypeId"), exports);
 __exportStar(require("./DuckDBValueConverter"), exports);
-__exportStar(require("./DuckDBValueToJsonConverter"), exports);
+__exportStar(require("./DuckDBValueConverters"), exports);
 __exportStar(require("./DuckDBVector"), exports);
-__exportStar(require("./configurationOptionDescriptions"), exports);
 __exportStar(require("./enums"), exports);
+__exportStar(require("./JS"), exports);
+__exportStar(require("./JSDuckDBValueConverter"), exports);
+__exportStar(require("./Json"), exports);
+__exportStar(require("./JsonDuckDBValueConverter"), exports);
 __exportStar(require("./sql"), exports);
 __exportStar(require("./values"), exports);
 __exportStar(require("./version"), exports);

package/lib/getColumnsFromChunks.js

@@ -3,14 +3,8 @@ 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));
-        }
+    for (const chunk of chunks) {
+        chunk.appendToColumns(columns);
     }
     return columns;
 }

package/lib/getColumnsObjectFromChunks.js

@@ -3,17 +3,8 @@ 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));
-        }
+    for (const chunk of chunks) {
+        chunk.appendToColumnsObject(columnNames, columnsObject);
     }
     return columnsObject;
 }

package/lib/getRowObjectsFromChunks.js

@@ -4,14 +4,7 @@ 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);
-        }
+        chunk.appendToRowObjects(columnNames, rowObjects);
     }
     return rowObjects;
 }

package/lib/getRowsFromChunks.js

@@ -4,7 +4,7 @@ exports.getRowsFromChunks = getRowsFromChunks;
 function getRowsFromChunks(chunks) {
     const rows = [];
     for (const chunk of chunks) {
-        chunk.visitRows((row) => rows.push(row));
+        chunk.appendToRows(rows);
     }
     return rows;
 }

package/lib/values/DuckDBBitValue.d.ts

@@ -13,4 +13,4 @@ export declare class DuckDBBitValue {
     static fromBools(bools: readonly boolean[]): DuckDBBitValue;
     static fromLengthAndPredicate(length: number, predicate: (index: number) => boolean): DuckDBBitValue;
 }
-export declare function bitValue(str: string): DuckDBBitValue;
+export declare function bitValue(input: string | readonly boolean[] | readonly number[]): DuckDBBitValue;

package/lib/values/DuckDBBitValue.js

@@ -87,6 +87,17 @@ class DuckDBBitValue {
     }
 }
 exports.DuckDBBitValue = DuckDBBitValue;
-function bitValue(str) {
-    return DuckDBBitValue.fromString(str);
+function bitValue(input) {
+    if (typeof input === 'string') {
+        return DuckDBBitValue.fromString(input);
+    }
+    if (input.length > 0) {
+        if (typeof input[0] === 'boolean') {
+            return DuckDBBitValue.fromBools(input);
+        }
+        else if (typeof input[0] === 'number') {
+            return DuckDBBitValue.fromBits(input);
+        }
+    }
+    return DuckDBBitValue.fromLengthAndPredicate(0, _ => false);
 }