@haybarn/node-api 1.5.6-rc1 → 2.0.0-rc3

package/lib/types/DuckDBUnionType.d.ts

@@ -0,0 +1,18 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import type { DuckDBType } from './DuckDBType';
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+export declare class DuckDBUnionType extends BaseDuckDBType<DuckDBTypeId.UNION> {
+    readonly memberTags: readonly string[];
+    readonly tagMemberIndexes: Readonly<Record<string, number>>;
+    readonly memberTypes: readonly DuckDBType[];
+    constructor(memberTags: readonly string[], memberTypes: readonly DuckDBType[], alias?: string);
+    memberIndexForTag(tag: string): number;
+    memberTypeForTag(tag: string): DuckDBType;
+    get memberCount(): number;
+    toString(): string;
+    toLogicalType(): DuckDBLogicalType;
+    toJson(): Json;
+}
+export declare function UNION(members: Record<string, DuckDBType>, alias?: string): DuckDBUnionType;

package/lib/types/DuckDBUnionType.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBUnionType = void 0;
+exports.UNION = UNION;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBLogicalType_1 = require("../DuckDBLogicalType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+const sql_1 = require("../sql");
+class DuckDBUnionType extends BaseDuckDBType_1.BaseDuckDBType {
+    memberTags;
+    tagMemberIndexes;
+    memberTypes;
+    constructor(memberTags, memberTypes, alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.UNION, alias);
+        if (memberTags.length !== memberTypes.length) {
+            throw new Error(`Could not create DuckDBUnionType: \
+        tags length (${memberTags.length}) does not match valueTypes length (${memberTypes.length})`);
+        }
+        this.memberTags = memberTags;
+        const tagMemberIndexes = {};
+        for (let i = 0; i < memberTags.length; i++) {
+            tagMemberIndexes[memberTags[i]] = i;
+        }
+        this.tagMemberIndexes = tagMemberIndexes;
+        this.memberTypes = memberTypes;
+    }
+    memberIndexForTag(tag) {
+        return this.tagMemberIndexes[tag];
+    }
+    memberTypeForTag(tag) {
+        return this.memberTypes[this.tagMemberIndexes[tag]];
+    }
+    get memberCount() {
+        return this.memberTags.length;
+    }
+    toString() {
+        const parts = [];
+        for (let i = 0; i < this.memberTags.length; i++) {
+            parts.push(`${(0, sql_1.quotedIdentifier)(this.memberTags[i])} ${this.memberTypes[i]}`);
+        }
+        return `UNION(${parts.join(', ')})`;
+    }
+    toLogicalType() {
+        const logicalType = DuckDBLogicalType_1.DuckDBLogicalType.createUnion(this.memberTags, this.memberTypes.map((t) => t.toLogicalType()));
+        if (this.alias) {
+            logicalType.alias = this.alias;
+        }
+        return logicalType;
+    }
+    toJson() {
+        return {
+            typeId: this.typeId,
+            memberTags: [...this.memberTags],
+            memberTypes: this.memberTypes.map(t => t.toJson()),
+            ...(this.alias ? { alias: this.alias } : {}),
+        };
+    }
+}
+exports.DuckDBUnionType = DuckDBUnionType;
+function UNION(members, alias) {
+    const memberTags = Object.keys(members);
+    const memberTypes = Object.values(members);
+    return new DuckDBUnionType(memberTags, memberTypes, alias);
+}

package/lib/types/DuckDBVarCharType.d.ts

@@ -0,0 +1,8 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+export declare class DuckDBVarCharType extends BaseDuckDBType<DuckDBTypeId.VARCHAR> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBVarCharType;
+    static create(alias?: string): DuckDBVarCharType;
+}
+export declare const VARCHAR: DuckDBVarCharType;

package/lib/types/DuckDBVarCharType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VARCHAR = exports.DuckDBVarCharType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBVarCharType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.VARCHAR, alias);
+    }
+    static instance = new DuckDBVarCharType();
+    static create(alias) {
+        return alias ? new DuckDBVarCharType(alias) : DuckDBVarCharType.instance;
+    }
+}
+exports.DuckDBVarCharType = DuckDBVarCharType;
+exports.VARCHAR = DuckDBVarCharType.instance;

package/lib/types/DuckDBVariantType.d.ts

@@ -0,0 +1,8 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+export declare class DuckDBVariantType extends BaseDuckDBType<DuckDBTypeId.VARIANT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBVariantType;
+    static create(alias?: string): DuckDBVariantType;
+}
+export declare const VARIANT: DuckDBVariantType;

package/lib/types/DuckDBVariantType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VARIANT = exports.DuckDBVariantType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBVariantType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.VARIANT, alias);
+    }
+    static instance = new DuckDBVariantType();
+    static create(alias) {
+        return alias ? new DuckDBVariantType(alias) : DuckDBVariantType.instance;
+    }
+}
+exports.DuckDBVariantType = DuckDBVariantType;
+exports.VARIANT = DuckDBVariantType.instance;

package/lib/types/index.d.ts

@@ -0,0 +1,44 @@
+export * from './BaseDuckDBType';
+export * from './DuckDBAnyType';
+export * from './DuckDBArrayType';
+export * from './DuckDBBigIntType';
+export * from './DuckDBBigNumType';
+export * from './DuckDBBitType';
+export * from './DuckDBBlobType';
+export * from './DuckDBBooleanType';
+export * from './DuckDBDateType';
+export * from './DuckDBDecimalType';
+export * from './DuckDBDoubleType';
+export * from './DuckDBEnumType';
+export * from './DuckDBFloatType';
+export * from './DuckDBGeometryType';
+export * from './DuckDBHugeIntType';
+export * from './DuckDBIntegerLiteralType';
+export * from './DuckDBIntegerType';
+export * from './DuckDBIntervalType';
+export * from './DuckDBListType';
+export * from './DuckDBMapType';
+export * from './DuckDBSQLNullType';
+export * from './DuckDBSmallIntType';
+export * from './DuckDBStringLiteralType';
+export * from './DuckDBStructType';
+export * from './DuckDBTimeNSType';
+export * from './DuckDBTimeTZType';
+export * from './DuckDBTimeType';
+export * from './DuckDBTimestampMillisecondsType';
+export * from './DuckDBTimestampNanosecondsType';
+export * from './DuckDBTimestampSecondsType';
+export * from './DuckDBTimestampTZType';
+export * from './DuckDBTimestampTZNanosecondsType';
+export * from './DuckDBTimestampType';
+export * from './DuckDBTinyIntType';
+export * from './DuckDBType';
+export * from './DuckDBUBigIntType';
+export * from './DuckDBUHugeIntType';
+export * from './DuckDBUIntegerType';
+export * from './DuckDBUSmallIntType';
+export * from './DuckDBUTinyIntType';
+export * from './DuckDBUUIDType';
+export * from './DuckDBUnionType';
+export * from './DuckDBVarCharType';
+export * from './DuckDBVariantType';

package/lib/types/index.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./BaseDuckDBType"), exports);
+__exportStar(require("./DuckDBAnyType"), exports);
+__exportStar(require("./DuckDBArrayType"), exports);
+__exportStar(require("./DuckDBBigIntType"), exports);
+__exportStar(require("./DuckDBBigNumType"), exports);
+__exportStar(require("./DuckDBBitType"), exports);
+__exportStar(require("./DuckDBBlobType"), exports);
+__exportStar(require("./DuckDBBooleanType"), exports);
+__exportStar(require("./DuckDBDateType"), exports);
+__exportStar(require("./DuckDBDecimalType"), exports);
+__exportStar(require("./DuckDBDoubleType"), exports);
+__exportStar(require("./DuckDBEnumType"), exports);
+__exportStar(require("./DuckDBFloatType"), exports);
+__exportStar(require("./DuckDBGeometryType"), exports);
+__exportStar(require("./DuckDBHugeIntType"), exports);
+__exportStar(require("./DuckDBIntegerLiteralType"), exports);
+__exportStar(require("./DuckDBIntegerType"), exports);
+__exportStar(require("./DuckDBIntervalType"), exports);
+__exportStar(require("./DuckDBListType"), exports);
+__exportStar(require("./DuckDBMapType"), exports);
+__exportStar(require("./DuckDBSQLNullType"), exports);
+__exportStar(require("./DuckDBSmallIntType"), exports);
+__exportStar(require("./DuckDBStringLiteralType"), exports);
+__exportStar(require("./DuckDBStructType"), exports);
+__exportStar(require("./DuckDBTimeNSType"), exports);
+__exportStar(require("./DuckDBTimeTZType"), exports);
+__exportStar(require("./DuckDBTimeType"), exports);
+__exportStar(require("./DuckDBTimestampMillisecondsType"), exports);
+__exportStar(require("./DuckDBTimestampNanosecondsType"), exports);
+__exportStar(require("./DuckDBTimestampSecondsType"), exports);
+__exportStar(require("./DuckDBTimestampTZType"), exports);
+__exportStar(require("./DuckDBTimestampTZNanosecondsType"), exports);
+__exportStar(require("./DuckDBTimestampType"), exports);
+__exportStar(require("./DuckDBTinyIntType"), exports);
+__exportStar(require("./DuckDBType"), exports);
+__exportStar(require("./DuckDBUBigIntType"), exports);
+__exportStar(require("./DuckDBUHugeIntType"), exports);
+__exportStar(require("./DuckDBUIntegerType"), exports);
+__exportStar(require("./DuckDBUSmallIntType"), exports);
+__exportStar(require("./DuckDBUTinyIntType"), exports);
+__exportStar(require("./DuckDBUUIDType"), exports);
+__exportStar(require("./DuckDBUnionType"), exports);
+__exportStar(require("./DuckDBVarCharType"), exports);
+__exportStar(require("./DuckDBVariantType"), exports);

package/lib/values/DuckDBGeometryValue.d.ts

@@ -0,0 +1,12 @@
+export declare class DuckDBGeometryValue {
+    /** In WKB. */
+    readonly bytes: Uint8Array;
+    /** Takes raw WKB. */
+    constructor(bytes: Uint8Array);
+    /** Returns WKB in string form matching DuckDB's BLOB-to-VARCHAR. */
+    toString(): string;
+    /** Takes WKB in string form matching DuckDB's BLOB-to-VARCHAR. */
+    static fromString(str: string): DuckDBGeometryValue;
+}
+/** Takes WKB, either raw or in string form matching DuckDB's BLOB-to-VARCHAR. */
+export declare function geometryValue(input: Uint8Array | string): DuckDBGeometryValue;

package/lib/values/DuckDBGeometryValue.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBGeometryValue = void 0;
+exports.geometryValue = geometryValue;
+const bytesFromString_1 = require("../conversion/bytesFromString");
+const stringFromBlob_1 = require("../conversion/stringFromBlob");
+class DuckDBGeometryValue {
+    /** In WKB. */
+    bytes;
+    /** Takes raw WKB. */
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    /** Returns WKB in string form matching DuckDB's BLOB-to-VARCHAR. */
+    toString() {
+        return (0, stringFromBlob_1.stringFromBlob)(this.bytes);
+    }
+    /** Takes WKB in string form matching DuckDB's BLOB-to-VARCHAR. */
+    static fromString(str) {
+        return new DuckDBGeometryValue(Buffer.from((0, bytesFromString_1.bytesFromString)(str)));
+    }
+}
+exports.DuckDBGeometryValue = DuckDBGeometryValue;
+/** Takes WKB, either raw or in string form matching DuckDB's BLOB-to-VARCHAR. */
+function geometryValue(input) {
+    if (typeof input === 'string') {
+        return DuckDBGeometryValue.fromString(input);
+    }
+    return new DuckDBGeometryValue(input);
+}

package/lib/values/DuckDBTimestampTZNanosecondsValue.d.ts

@@ -0,0 +1,14 @@
+import { TimestampNanoseconds } from '@haybarn/node-bindings';
+export declare class DuckDBTimestampTZNanosecondsValue implements TimestampNanoseconds {
+    readonly nanos: bigint;
+    constructor(nanos: bigint);
+    get isFinite(): boolean;
+    /** Formats in the time zone set by `DuckDBTimestampTZValue.timezoneOffsetInMinutes`. */
+    toString(): string;
+    static readonly Epoch: DuckDBTimestampTZNanosecondsValue;
+    static readonly Max: DuckDBTimestampTZNanosecondsValue;
+    static readonly Min: DuckDBTimestampTZNanosecondsValue;
+    static readonly PosInf: DuckDBTimestampTZNanosecondsValue;
+    static readonly NegInf: DuckDBTimestampTZNanosecondsValue;
+}
+export declare function timestampTZNanosValue(nanos: bigint): DuckDBTimestampTZNanosecondsValue;

package/lib/values/DuckDBTimestampTZNanosecondsValue.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimestampTZNanosecondsValue = void 0;
+exports.timestampTZNanosValue = timestampTZNanosValue;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const dateTimeStringConversion_1 = require("../conversion/dateTimeStringConversion");
+const DuckDBTimestampNanosecondsValue_1 = require("./DuckDBTimestampNanosecondsValue");
+const DuckDBTimestampTZValue_1 = require("./DuckDBTimestampTZValue");
+class DuckDBTimestampTZNanosecondsValue {
+    nanos;
+    constructor(nanos) {
+        this.nanos = nanos;
+    }
+    get isFinite() {
+        return node_bindings_1.default.is_finite_timestamp_ns(this);
+    }
+    /** Formats in the time zone set by `DuckDBTimestampTZValue.timezoneOffsetInMinutes`. */
+    toString() {
+        return (0, dateTimeStringConversion_1.getDuckDBTimestampStringFromNanoseconds)(this.nanos, DuckDBTimestampTZValue_1.DuckDBTimestampTZValue.timezoneOffsetInMinutes);
+    }
+    static Epoch = new DuckDBTimestampTZNanosecondsValue(0n);
+    static Max = new DuckDBTimestampTZNanosecondsValue(DuckDBTimestampNanosecondsValue_1.DuckDBTimestampNanosecondsValue.Max.nanos);
+    static Min = new DuckDBTimestampTZNanosecondsValue(DuckDBTimestampNanosecondsValue_1.DuckDBTimestampNanosecondsValue.Min.nanos);
+    static PosInf = new DuckDBTimestampTZNanosecondsValue(DuckDBTimestampNanosecondsValue_1.DuckDBTimestampNanosecondsValue.PosInf.nanos);
+    static NegInf = new DuckDBTimestampTZNanosecondsValue(DuckDBTimestampNanosecondsValue_1.DuckDBTimestampNanosecondsValue.NegInf.nanos);
+}
+exports.DuckDBTimestampTZNanosecondsValue = DuckDBTimestampTZNanosecondsValue;
+function timestampTZNanosValue(nanos) {
+    return new DuckDBTimestampTZNanosecondsValue(nanos);
+}

package/lib/values/DuckDBTupleValue.d.ts

@@ -0,0 +1,11 @@
+import { DuckDBValue } from './DuckDBValue';
+/**
+ * A value of a tuple type: an unnamed STRUCT, such as `(1, 'a')` or
+ * `row(1, 'a')`. Its items are in entry order.
+ */
+export declare class DuckDBTupleValue {
+    readonly items: readonly DuckDBValue[];
+    constructor(items: readonly DuckDBValue[]);
+    toString(): string;
+}
+export declare function tupleValue(items: readonly DuckDBValue[]): DuckDBTupleValue;

package/lib/values/DuckDBTupleValue.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTupleValue = void 0;
+exports.tupleValue = tupleValue;
+const displayStringForDuckDBValue_1 = require("../conversion/displayStringForDuckDBValue");
+/**
+ * A value of a tuple type: an unnamed STRUCT, such as `(1, 'a')` or
+ * `row(1, 'a')`. Its items are in entry order.
+ */
+class DuckDBTupleValue {
+    items;
+    constructor(items) {
+        this.items = items;
+    }
+    toString() {
+        return `(${this.items.map(displayStringForDuckDBValue_1.displayStringForDuckDBValue).join(', ')})`;
+    }
+}
+exports.DuckDBTupleValue = DuckDBTupleValue;
+function tupleValue(items) {
+    return new DuckDBTupleValue(items);
+}

package/lib/values/DuckDBUUIDValue.js

@@ -20,7 +20,11 @@ class DuckDBUUIDValue {
     }
     /** Create a DuckDBUUIDValue from an unsigned 128-bit integer in a JS BigInt. */
     static fromUint128(uint128) {
-        return new DuckDBUUIDValue((uint128 ^ 0x80000000000000000000000000000000n) & 0xffffffffffffffffffffffffffffffffn);
+        // Convert the unsigned 128-bit input into DuckDB's storage form: MSB
+        // flipped (so numeric ordering matches string ordering) and held as a
+        // signed int128 (the same form `DuckDBUUIDVector` produces via
+        // `getInt128`).
+        return new DuckDBUUIDValue(BigInt.asIntN(128, uint128 ^ 0x80000000000000000000000000000000n));
     }
     /**
      * Create a DuckDBUUIDValue from a HUGEINT as stored by DuckDB.

package/lib/values/DuckDBValue.d.ts

@@ -3,6 +3,7 @@ import { DuckDBBitValue } from './DuckDBBitValue';
 import { DuckDBBlobValue } from './DuckDBBlobValue';
 import { DuckDBDateValue } from './DuckDBDateValue';
 import { DuckDBDecimalValue } from './DuckDBDecimalValue';
+import { DuckDBGeometryValue } from './DuckDBGeometryValue';
 import { DuckDBIntervalValue } from './DuckDBIntervalValue';
 import { DuckDBListValue } from './DuckDBListValue';
 import { DuckDBMapValue } from './DuckDBMapValue';
@@ -12,9 +13,12 @@ import { DuckDBTimestampMillisecondsValue } from './DuckDBTimestampMillisecondsV
 import { DuckDBTimestampNanosecondsValue } from './DuckDBTimestampNanosecondsValue';
 import { DuckDBTimestampSecondsValue } from './DuckDBTimestampSecondsValue';
 import { DuckDBTimestampTZValue } from './DuckDBTimestampTZValue';
+import { DuckDBTimestampTZNanosecondsValue } from './DuckDBTimestampTZNanosecondsValue';
 import { DuckDBTimestampValue } from './DuckDBTimestampValue';
 import { DuckDBTimeTZValue } from './DuckDBTimeTZValue';
 import { DuckDBTimeValue } from './DuckDBTimeValue';
+import { DuckDBTupleValue } from './DuckDBTupleValue';
 import { DuckDBUnionValue } from './DuckDBUnionValue';
 import { DuckDBUUIDValue } from './DuckDBUUIDValue';
-export type DuckDBValue = null | boolean | number | bigint | string | DuckDBArrayValue | DuckDBBitValue | DuckDBBlobValue | DuckDBDateValue | DuckDBDecimalValue | DuckDBIntervalValue | DuckDBListValue | DuckDBMapValue | DuckDBStructValue | DuckDBTimestampMillisecondsValue | DuckDBTimestampNanosecondsValue | DuckDBTimestampSecondsValue | DuckDBTimestampTZValue | DuckDBTimestampValue | DuckDBTimeTZValue | DuckDBTimeValue | DuckDBTimeNSValue | DuckDBUnionValue | DuckDBUUIDValue;
+import { DuckDBVariantValue } from './DuckDBVariantValue';
+export type DuckDBValue = null | boolean | number | bigint | string | DuckDBArrayValue | DuckDBBitValue | DuckDBBlobValue | DuckDBDateValue | DuckDBDecimalValue | DuckDBGeometryValue | DuckDBIntervalValue | DuckDBListValue | DuckDBMapValue | DuckDBStructValue | DuckDBTimestampMillisecondsValue | DuckDBTimestampNanosecondsValue | DuckDBTimestampSecondsValue | DuckDBTimestampTZValue | DuckDBTimestampTZNanosecondsValue | DuckDBTimestampValue | DuckDBTimeTZValue | DuckDBTimeValue | DuckDBTimeNSValue | DuckDBTupleValue | DuckDBUnionValue | DuckDBUUIDValue | DuckDBVariantValue;

package/lib/values/DuckDBVariantValue.d.ts

@@ -0,0 +1,19 @@
+import type { DuckDBType } from '../DuckDBType';
+import { DuckDBValue } from './DuckDBValue';
+/**
+ * Wraps a single decoded VARIANT row value. The wrapper distinguishes a
+ * SQL-NULL row (returned as bare `null`) from an embedded `VARIANT_NULL`
+ * tag (returned as `new DuckDBVariantValue(null)`).
+ *
+ * The optional `type` records the exact DuckDB type of the inner value
+ * (recovered from the on-disk variant tag at decode time). The append /
+ * bind paths use it so heterogeneous content round-trips faithfully —
+ * `typeForValue` is a best-effort fallback when `type` is not provided.
+ */
+export declare class DuckDBVariantValue {
+    readonly value: DuckDBValue;
+    readonly type?: DuckDBType;
+    constructor(value: DuckDBValue, type?: DuckDBType);
+    toString(): string;
+}
+export declare function variantValue(value: DuckDBValue, type?: DuckDBType): DuckDBVariantValue;

package/lib/values/DuckDBVariantValue.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBVariantValue = void 0;
+exports.variantValue = variantValue;
+const displayStringForDuckDBValue_1 = require("../conversion/displayStringForDuckDBValue");
+/**
+ * Wraps a single decoded VARIANT row value. The wrapper distinguishes a
+ * SQL-NULL row (returned as bare `null`) from an embedded `VARIANT_NULL`
+ * tag (returned as `new DuckDBVariantValue(null)`).
+ *
+ * The optional `type` records the exact DuckDB type of the inner value
+ * (recovered from the on-disk variant tag at decode time). The append /
+ * bind paths use it so heterogeneous content round-trips faithfully —
+ * `typeForValue` is a best-effort fallback when `type` is not provided.
+ */
+class DuckDBVariantValue {
+    value;
+    type;
+    constructor(value, type) {
+        this.value = value;
+        this.type = type;
+    }
+    toString() {
+        return (0, displayStringForDuckDBValue_1.displayStringForDuckDBValue)(this.value);
+    }
+}
+exports.DuckDBVariantValue = DuckDBVariantValue;
+function variantValue(value, type) {
+    return new DuckDBVariantValue(value, type);
+}

package/lib/values/index.d.ts

@@ -3,6 +3,7 @@ export * from './DuckDBBitValue';
 export * from './DuckDBBlobValue';
 export * from './DuckDBDateValue';
 export * from './DuckDBDecimalValue';
+export * from './DuckDBGeometryValue';
 export * from './DuckDBIntervalValue';
 export * from './DuckDBListValue';
 export * from './DuckDBMapValue';
@@ -12,9 +13,12 @@ export * from './DuckDBTimestampMillisecondsValue';
 export * from './DuckDBTimestampNanosecondsValue';
 export * from './DuckDBTimestampSecondsValue';
 export * from './DuckDBTimestampTZValue';
+export * from './DuckDBTimestampTZNanosecondsValue';
 export * from './DuckDBTimestampValue';
 export * from './DuckDBTimeTZValue';
 export * from './DuckDBTimeValue';
+export * from './DuckDBTupleValue';
 export * from './DuckDBUnionValue';
 export * from './DuckDBUUIDValue';
 export * from './DuckDBValue';
+export * from './DuckDBVariantValue';

package/lib/values/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./DuckDBBitValue"), exports);
 __exportStar(require("./DuckDBBlobValue"), exports);
 __exportStar(require("./DuckDBDateValue"), exports);
 __exportStar(require("./DuckDBDecimalValue"), exports);
+__exportStar(require("./DuckDBGeometryValue"), exports);
 __exportStar(require("./DuckDBIntervalValue"), exports);
 __exportStar(require("./DuckDBListValue"), exports);
 __exportStar(require("./DuckDBMapValue"), exports);
@@ -28,9 +29,12 @@ __exportStar(require("./DuckDBTimestampMillisecondsValue"), exports);
 __exportStar(require("./DuckDBTimestampNanosecondsValue"), exports);
 __exportStar(require("./DuckDBTimestampSecondsValue"), exports);
 __exportStar(require("./DuckDBTimestampTZValue"), exports);
+__exportStar(require("./DuckDBTimestampTZNanosecondsValue"), exports);
 __exportStar(require("./DuckDBTimestampValue"), exports);
 __exportStar(require("./DuckDBTimeTZValue"), exports);
 __exportStar(require("./DuckDBTimeValue"), exports);
+__exportStar(require("./DuckDBTupleValue"), exports);
 __exportStar(require("./DuckDBUnionValue"), exports);
 __exportStar(require("./DuckDBUUIDValue"), exports);
 __exportStar(require("./DuckDBValue"), exports);
+__exportStar(require("./DuckDBVariantValue"), exports);

package/lib/vectors/DuckDBArrayVector.d.ts

@@ -0,0 +1,21 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBArrayType } from '../DuckDBType';
+import { DuckDBArrayValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBArrayVector extends DuckDBVector<DuckDBArrayValue> {
+    private readonly arrayType;
+    private readonly validity;
+    private readonly vector;
+    private readonly childData;
+    private readonly _itemCount;
+    constructor(arrayType: DuckDBArrayType, validity: DuckDBValidity, vector: duckdb.Vector, childData: DuckDBVector, itemCount: number);
+    static fromRawVector(arrayType: DuckDBArrayType, vector: duckdb.Vector, itemCount: number): DuckDBArrayVector;
+    private static itemSize;
+    get type(): DuckDBArrayType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBArrayValue | null;
+    setItem(itemIndex: number, value: DuckDBArrayValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBArrayVector;
+}

package/lib/vectors/DuckDBArrayVector.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBArrayVector = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBType_1 = require("../DuckDBType");
+const values_1 = require("../values");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+class DuckDBArrayVector extends DuckDBVector_1.DuckDBVector {
+    arrayType;
+    validity;
+    vector;
+    childData;
+    _itemCount;
+    constructor(arrayType, validity, vector, childData, itemCount) {
+        super();
+        this.arrayType = arrayType;
+        this.validity = validity;
+        this.vector = vector;
+        this.childData = childData;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(arrayType, vector, itemCount) {
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        const child_vector = node_bindings_1.default.array_vector_get_child(vector);
+        const childItemsPerArray = DuckDBArrayVector.itemSize(arrayType) * arrayType.length;
+        const childData = DuckDBVector_1.DuckDBVector.create(child_vector, itemCount * childItemsPerArray, arrayType.valueType);
+        return new DuckDBArrayVector(arrayType, validity, vector, childData, itemCount);
+    }
+    static itemSize(arrayType) {
+        if (arrayType.valueType instanceof DuckDBType_1.DuckDBArrayType) {
+            return DuckDBArrayVector.itemSize(arrayType.valueType);
+        }
+        else {
+            return 1;
+        }
+    }
+    get type() {
+        return this.arrayType;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        return new values_1.DuckDBArrayValue(this.childData
+            .slice(itemIndex * this.arrayType.length, this.arrayType.length)
+            .toArray());
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            const startIndex = itemIndex * this.arrayType.length;
+            for (let i = 0; i < this.arrayType.length; i++) {
+                this.childData.setItem(startIndex + i, value.items[i]);
+            }
+            this.validity.setItemValid(itemIndex, true);
+        }
+        else {
+            const startIndex = itemIndex * this.arrayType.length;
+            for (let i = 0; i < this.arrayType.length; i++) {
+                this.childData.setItem(startIndex + i, null);
+            }
+            this.validity.setItemValid(itemIndex, false);
+        }
+    }
+    flush() {
+        this.childData.flush();
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBArrayVector(this.arrayType, this.validity.slice(offset, length), this.vector, this.childData.slice(offset * this.arrayType.length, length * this.arrayType.length), length);
+    }
+}
+exports.DuckDBArrayVector = DuckDBArrayVector;

package/lib/vectors/DuckDBBigIntVector.d.ts

@@ -0,0 +1,17 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBBigIntType } from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBBigIntVector extends DuckDBVector<bigint> {
+    private readonly items;
+    private readonly validity;
+    private readonly vector;
+    constructor(items: BigInt64Array, validity: DuckDBValidity, vector: duckdb.Vector);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBBigIntVector;
+    get type(): DuckDBBigIntType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    setItem(itemIndex: number, value: bigint | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBBigIntVector;
+}