@haybarn/node-api 1.5.3-rc2

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,49 @@
+"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.BIGNUM]: DuckDBValueConverters_1.bigintFromBigIntValue,
+    [DuckDBTypeId_1.DuckDBTypeId.SQLNULL]: DuckDBValueConverters_1.nullConverter,
+    [DuckDBTypeId_1.DuckDBTypeId.STRING_LITERAL]: DuckDBValueConverters_1.unsupportedConverter,
+    [DuckDBTypeId_1.DuckDBTypeId.INTEGER_LITERAL]: DuckDBValueConverters_1.unsupportedConverter,
+    [DuckDBTypeId_1.DuckDBTypeId.TIME_NS]: DuckDBValueConverters_1.bigintFromTimeValue,
+};
+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,49 @@
+"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.BIGNUM]: DuckDBValueConverters_1.stringFromValue,
+    [DuckDBTypeId_1.DuckDBTypeId.SQLNULL]: DuckDBValueConverters_1.nullConverter,
+    [DuckDBTypeId_1.DuckDBTypeId.STRING_LITERAL]: DuckDBValueConverters_1.unsupportedConverter,
+    [DuckDBTypeId_1.DuckDBTypeId.INTEGER_LITERAL]: DuckDBValueConverters_1.unsupportedConverter,
+    [DuckDBTypeId_1.DuckDBTypeId.TIME_NS]: DuckDBValueConverters_1.stringFromValue,
+};
+exports.JsonDuckDBValueConverter = (0, createDuckDBValueConverter_1.createDuckDBValueConverter)(JsonConvertersByTypeId);

package/lib/configurationOptionDescriptions.d.ts

@@ -0,0 +1 @@
+export declare function configurationOptionDescriptions(): Readonly<Record<string, string>>;

package/lib/configurationOptionDescriptions.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configurationOptionDescriptions = configurationOptionDescriptions;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+function configurationOptionDescriptions() {
+    const descriptions = {};
+    const count = node_bindings_1.default.config_count();
+    for (let i = 0; i < count; i++) {
+        const { name, description } = node_bindings_1.default.get_config_flag(i);
+        descriptions[name] = description;
+    }
+    return descriptions;
+}

package/lib/conversion/bytesFromString.d.ts

@@ -0,0 +1 @@
+export declare function bytesFromString(str: string): Uint8Array;

package/lib/conversion/bytesFromString.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bytesFromString = bytesFromString;
+const textEncoder = new TextEncoder();
+function bytesFromString(str) {
+    return textEncoder.encode(str);
+}

package/lib/conversion/dateTimeStringConversion.d.ts

@@ -0,0 +1,20 @@
+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;
+export declare function getDuckDBTimeStringFromPositiveNanoseconds(positiveNanoseconds: bigint): string;
+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, 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

@@ -0,0 +1,238 @@
+"use strict";
+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;
+exports.getDuckDBTimeStringFromPositiveNanoseconds = getDuckDBTimeStringFromPositiveNanoseconds;
+exports.getDuckDBTimeStringFromMicrosecondsInDay = getDuckDBTimeStringFromMicrosecondsInDay;
+exports.getDuckDBTimeStringFromNanosecondsInDay = getDuckDBTimeStringFromNanosecondsInDay;
+exports.getDuckDBTimeStringFromMicroseconds = getDuckDBTimeStringFromMicroseconds;
+exports.getDuckDBTimestampStringFromDaysAndMicroseconds = getDuckDBTimestampStringFromDaysAndMicroseconds;
+exports.getDuckDBTimestampStringFromDaysAndNanoseconds = getDuckDBTimestampStringFromDaysAndNanoseconds;
+exports.getDuckDBTimestampStringFromMicroseconds = getDuckDBTimestampStringFromMicroseconds;
+exports.getDuckDBTimestampStringFromSeconds = getDuckDBTimestampStringFromSeconds;
+exports.getDuckDBTimestampStringFromMilliseconds = getDuckDBTimestampStringFromMilliseconds;
+exports.getDuckDBTimestampStringFromNanoseconds = getDuckDBTimestampStringFromNanoseconds;
+exports.getDuckDBIntervalString = getDuckDBIntervalString;
+const DAYS_IN_400_YEARS = 146097; // (((365 * 4 + 1) * 25) - 1) * 4 + 1
+const MILLISECONDS_PER_DAY_NUM = 86400000; // 1000 * 60 * 60 * 24
+const MICROSECONDS_PER_SECOND = 1000000n;
+const MICROSECONDS_PER_MILLISECOND = 1000n;
+const NANOSECONDS_PER_SECOND = 1000000000n;
+const SECONDS_PER_MINUTE = 60n;
+const MINUTES_PER_HOUR = 60n;
+const MICROSECONDS_PER_DAY = 86400000000n; // 24 * 60 * 60 * 1000000
+const NANOSECONDS_PER_DAY = 86400000000000n; // 24 * 60 * 60 * 1000000000
+const NEGATIVE_INFINITY_TIMESTAMP = -9223372036854775807n; // -(2^63-1)
+const POSITIVE_INFINITY_TIMESTAMP = 9223372036854775807n; // 2^63-1
+function getDuckDBDateStringFromYearMonthDay(year, month, dayOfMonth) {
+    const yearStr = String(Math.abs(year)).padStart(4, '0');
+    const monthStr = String(month).padStart(2, '0');
+    const dayOfMonthStr = String(dayOfMonth).padStart(2, '0');
+    return `${yearStr}-${monthStr}-${dayOfMonthStr}${year < 0 ? ' (BC)' : ''}`;
+}
+function getDuckDBDateStringFromDays(days) {
+    const absDays = Math.abs(days);
+    const sign = days < 0 ? -1 : 1;
+    // 400 years is the shortest interval with a fixed number of days. (Leap years and different length months can result
+    // in shorter intervals having different number of days.) By separating the number of 400 year intervals from the
+    // interval covered by the remaining days, we can guarantee that the date resulting from shifting the epoch by the
+    // remaining interval is within the valid range of the JS Date object. This allows us to use JS Date to calculate the
+    // year, month, and day of month for the date represented by the remaining interval, thus accounting for leap years
+    // and different length months. We can then safely add back the years from the 400 year intervals, because the month
+    // and day of month won't change when a date is shifted by a whole number of such intervals.
+    const num400YearIntervals = Math.floor(absDays / DAYS_IN_400_YEARS);
+    const yearsFrom400YearIntervals = sign * num400YearIntervals * 400;
+    const absDaysFromRemainingInterval = absDays % DAYS_IN_400_YEARS;
+    const millisecondsFromRemainingInterval = sign * absDaysFromRemainingInterval * MILLISECONDS_PER_DAY_NUM;
+    const date = new Date(millisecondsFromRemainingInterval);
+    let year = yearsFrom400YearIntervals + date.getUTCFullYear();
+    if (year < 0) {
+        year--; // correct for non-existence of year zero
+    }
+    const month = date.getUTCMonth() + 1; // getUTCMonth returns zero-indexed month, but we want a one-index month for display
+    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');
+    const secondsStr = String(secondsPart).padStart(2, '0');
+    const microsecondsStr = String(microsecondsPart)
+        .padStart(6, '0')
+        .replace(/0+$/, '');
+    return `${hoursStr}:${minutesStr}:${secondsStr}${microsecondsStr.length > 0 ? `.${microsecondsStr}` : ''}`;
+}
+function getDuckDBTimeStringFromPartsNS(hoursPart, minutesPart, secondsPart, nanosecondsPart) {
+    const hoursStr = String(hoursPart).padStart(2, '0');
+    const minutesStr = String(minutesPart).padStart(2, '0');
+    const secondsStr = String(secondsPart).padStart(2, '0');
+    const nanosecondsStr = String(nanosecondsPart)
+        .padStart(9, '0')
+        .replace(/0+$/, '');
+    return `${hoursStr}:${minutesStr}:${secondsStr}${nanosecondsStr.length > 0 ? `.${nanosecondsStr}` : ''}`;
+}
+function getDuckDBTimeStringFromPositiveMicroseconds(positiveMicroseconds) {
+    const microsecondsPart = positiveMicroseconds % MICROSECONDS_PER_SECOND;
+    const seconds = positiveMicroseconds / MICROSECONDS_PER_SECOND;
+    const secondsPart = seconds % SECONDS_PER_MINUTE;
+    const minutes = seconds / SECONDS_PER_MINUTE;
+    const minutesPart = minutes % MINUTES_PER_HOUR;
+    const hoursPart = minutes / MINUTES_PER_HOUR;
+    return getDuckDBTimeStringFromParts(hoursPart, minutesPart, secondsPart, microsecondsPart);
+}
+function getDuckDBTimeStringFromPositiveNanoseconds(positiveNanoseconds) {
+    const nanosecondsPart = positiveNanoseconds % NANOSECONDS_PER_SECOND;
+    const seconds = positiveNanoseconds / NANOSECONDS_PER_SECOND;
+    const secondsPart = seconds % SECONDS_PER_MINUTE;
+    const minutes = seconds / SECONDS_PER_MINUTE;
+    const minutesPart = minutes % MINUTES_PER_HOUR;
+    const hoursPart = minutes / MINUTES_PER_HOUR;
+    return getDuckDBTimeStringFromPartsNS(hoursPart, minutesPart, secondsPart, nanosecondsPart);
+}
+function getDuckDBTimeStringFromMicrosecondsInDay(microsecondsInDay) {
+    const positiveMicroseconds = microsecondsInDay < 0
+        ? microsecondsInDay + MICROSECONDS_PER_DAY
+        : microsecondsInDay;
+    return getDuckDBTimeStringFromPositiveMicroseconds(positiveMicroseconds);
+}
+function getDuckDBTimeStringFromNanosecondsInDay(nanosecondsInDay) {
+    const positiveNanoseconds = nanosecondsInDay < 0
+        ? nanosecondsInDay + NANOSECONDS_PER_DAY
+        : nanosecondsInDay;
+    return getDuckDBTimeStringFromPositiveNanoseconds(positiveNanoseconds);
+}
+function getDuckDBTimeStringFromMicroseconds(microseconds) {
+    const negative = microseconds < 0;
+    const positiveMicroseconds = negative ? -microseconds : microseconds;
+    const positiveString = getDuckDBTimeStringFromPositiveMicroseconds(positiveMicroseconds);
+    return negative ? `-${positiveString}` : positiveString;
+}
+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);
+    return `${dateStr} ${timeStr}${timezonePart ?? ''}`;
+}
+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);
+    return `${dateStr} ${timeStr}`;
+}
+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) {
+        return '-infinity';
+    }
+    if (microseconds === POSITIVE_INFINITY_TIMESTAMP) {
+        return 'infinity';
+    }
+    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, getTimezoneOffsetString(timezoneOffsetInMinutes));
+}
+function getDuckDBTimestampStringFromSeconds(seconds) {
+    return getDuckDBTimestampStringFromMicroseconds(seconds * MICROSECONDS_PER_SECOND);
+}
+function getDuckDBTimestampStringFromMilliseconds(milliseconds) {
+    return getDuckDBTimestampStringFromMicroseconds(milliseconds * MICROSECONDS_PER_MILLISECOND);
+}
+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);
+}
+// Assumes baseUnit can be pluralized by adding an 's'.
+function numberAndUnit(value, baseUnit) {
+    return `${value} ${baseUnit}${Math.abs(value) !== 1 ? 's' : ''}`;
+}
+function getDuckDBIntervalString(months, days, microseconds) {
+    const parts = [];
+    if (months !== 0) {
+        const sign = months < 0 ? -1 : 1;
+        const absMonths = Math.abs(months);
+        const absYears = Math.floor(absMonths / 12);
+        const years = sign * absYears;
+        const extraMonths = sign * (absMonths - absYears * 12);
+        if (years !== 0) {
+            parts.push(numberAndUnit(years, 'year'));
+        }
+        if (extraMonths !== 0) {
+            parts.push(numberAndUnit(extraMonths, 'month'));
+        }
+    }
+    if (days !== 0) {
+        parts.push(numberAndUnit(days, 'day'));
+    }
+    if (microseconds !== 0n) {
+        parts.push(getDuckDBTimeStringFromMicroseconds(microseconds));
+    }
+    if (parts.length > 0) {
+        return parts.join(' ');
+    }
+    return '00:00:00';
+}

package/lib/conversion/displayStringForDuckDBValue.d.ts

@@ -0,0 +1,2 @@
+import { DuckDBValue } from '../values';
+export declare function displayStringForDuckDBValue(value: DuckDBValue): string;

package/lib/conversion/displayStringForDuckDBValue.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayStringForDuckDBValue = displayStringForDuckDBValue;
+const sql_1 = require("../sql");
+function displayStringForDuckDBValue(value) {
+    if (value == null) {
+        return 'NULL';
+    }
+    if (typeof value === 'string') {
+        return (0, sql_1.quotedString)(value);
+    }
+    return value.toString();
+}

package/lib/conversion/stringFromBlob.d.ts

@@ -0,0 +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

@@ -0,0 +1,45 @@
+"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 /* double quote */ ||
+            byte === 0x27 /* single quote */ ||
+            byte >= 0x7f) {
+            byteStrings.push(`\\x${byte.toString(16).toUpperCase().padStart(2, '0')}`);
+        }
+        else {
+            byteStrings.push(String.fromCharCode(byte));
+        }
+    }
+    return byteStrings.join('');
+}

package/lib/conversion/stringFromDecimal.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Decimal string formatting.
+ *
+ * Supports a subset of the functionality of `BigInt.prototype.toLocaleString` for locale-specific formatting.
+ */
+export interface DuckDBDecimalFormatOptions {
+    useGrouping?: boolean;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+}
+export interface LocaleOptions {
+    locales?: string | string[];
+    options?: DuckDBDecimalFormatOptions;
+}
+/**
+ * Convert a scaled decimal value to a string, possibly using locale-specific formatting.
+ */
+export declare function stringFromDecimal(scaledValue: bigint, scale: number, localeOptions?: LocaleOptions): string;

package/lib/conversion/stringFromDecimal.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Decimal string formatting.
+ *
+ * Supports a subset of the functionality of `BigInt.prototype.toLocaleString` for locale-specific formatting.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringFromDecimal = stringFromDecimal;
+/*
+ * Get the decimal separator for a given locale.
+ * Somewhat expensive, so use getCachedDecimalSeparator if you need to call this multiple times.
+ */
+function getDecimalSeparator(locales) {
+    const decimalSeparator = new Intl.NumberFormat(locales, { useGrouping: false })
+        .formatToParts(0.1)
+        .find((part) => part.type === 'decimal')?.value ?? '.';
+    return decimalSeparator;
+}
+/*
+ * Get the decimal separator for a given locale, and cache the result.
+ */
+const cachedDecimalSeparators = {};
+function getCachedDecimalSeparator(locales) {
+    const cacheKey = JSON.stringify(locales);
+    if (cacheKey in cachedDecimalSeparators) {
+        return cachedDecimalSeparators[cacheKey];
+    }
+    const decimalSeparator = getDecimalSeparator(locales);
+    cachedDecimalSeparators[cacheKey] = decimalSeparator;
+    return decimalSeparator;
+}
+// Helper function to format whole part of a decimal value.
+// Note that we explicitly omit 'minimumFractionDigits' and 'maximumFractionDigits' from the options
+// passed to toLocaleString, because they are only relevant for the fractional part of the number, and
+// would result in formatting the whole part as a real number, which we don't want.
+function formatWholePart(localeOptions, val) {
+    if (localeOptions) {
+        const { minimumFractionDigits: _minFD, maximumFractionDigits: _maxFD, ...restOptions } = localeOptions.options ?? {};
+        return val.toLocaleString(localeOptions?.locales, restOptions);
+    }
+    return String(val);
+}
+// Format the fractional part of a decimal value
+// Note that we must handle minimumFractionDigits and maximumFractionDigits ourselves, and that
+// we don't apply `useGrouping` because that only applies to the whole part of the number.
+function formatFractionalPart(localeOptions, val, scale) {
+    const fractionalPartStr = String(val).padStart(scale, '0');
+    if (!localeOptions) {
+        return fractionalPartStr;
+    }
+    const minFracDigits = localeOptions?.options?.minimumFractionDigits ?? 0;
+    const maxFracDigits = localeOptions?.options?.maximumFractionDigits ?? 20;
+    return fractionalPartStr.padEnd(minFracDigits, '0').slice(0, maxFracDigits);
+}
+/**
+ * Convert a scaled decimal value to a string, possibly using locale-specific formatting.
+ */
+function stringFromDecimal(scaledValue, scale, localeOptions) {
+    // Decimal values are represented as integers that have been scaled up by a power of ten. The `scale` property of
+    // the type is the exponent of the scale factor. For a scale greater than zero, we need to separate out the
+    // fractional part by reversing this scaling.
+    if (scale > 0) {
+        const scaleFactor = BigInt(10) ** BigInt(scale);
+        const absScaledValue = scaledValue < 0 ? -scaledValue : scaledValue;
+        const prefix = scaledValue < 0 ? '-' : '';
+        const wholePartNum = absScaledValue / scaleFactor;
+        const wholePartStr = formatWholePart(localeOptions, wholePartNum);
+        const fractionalPartNum = absScaledValue % scaleFactor;
+        const fractionalPartStr = formatFractionalPart(localeOptions, fractionalPartNum, scale);
+        const decimalSeparatorStr = localeOptions
+            ? getCachedDecimalSeparator(localeOptions.locales)
+            : '.';
+        return `${prefix}${wholePartStr}${decimalSeparatorStr}${fractionalPartStr}`;
+    }
+    // For a scale of zero, there is no fractional part, so a direct string conversion works.
+    if (localeOptions) {
+        return scaledValue.toLocaleString(localeOptions?.locales, localeOptions?.options);
+    }
+    return String(scaledValue);
+}

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 | null)[][];

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(value, type, converter)));
+        }
+    }
+    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 | null)[]>;

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(value, type, converter)));
+        }
+    }
+    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 | null>[];