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

package/lib/vectors/DuckDBUIntegerVector.d.ts

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

package/lib/vectors/DuckDBUIntegerVector.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBUIntegerVector = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBType_1 = require("../DuckDBType");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+const dataAccessors_1 = require("./dataAccessors");
+class DuckDBUIntegerVector extends DuckDBVector_1.DuckDBVector {
+    items;
+    validity;
+    vector;
+    constructor(items, validity, vector) {
+        super();
+        this.items = items;
+        this.validity = validity;
+        this.vector = vector;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * Uint32Array.BYTES_PER_ELEMENT);
+        const items = new Uint32Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBUIntegerVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBUIntegerType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            // Checked inline for bulk-write throughput; see dataAccessors.ts.
+            if (!Number.isInteger(value)) {
+                throw new Error(`number is not an integer`);
+            }
+            if (value < 0 || value > 4294967295) {
+                throw new Error(`number out of uint32 range`);
+            }
+            this.items[itemIndex] = value;
+            this.validity.setItemValid(itemIndex, true);
+        }
+        else {
+            this.validity.setItemValid(itemIndex, false);
+        }
+    }
+    flush() {
+        node_bindings_1.default.copy_data_to_vector(this.vector, 0, this.items.buffer, this.items.byteOffset, this.items.byteLength);
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBUIntegerVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBUIntegerVector = DuckDBUIntegerVector;

package/lib/vectors/DuckDBUSmallIntVector.d.ts

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

package/lib/vectors/DuckDBUSmallIntVector.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBUSmallIntVector = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBType_1 = require("../DuckDBType");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+const dataAccessors_1 = require("./dataAccessors");
+class DuckDBUSmallIntVector extends DuckDBVector_1.DuckDBVector {
+    items;
+    validity;
+    vector;
+    constructor(items, validity, vector) {
+        super();
+        this.items = items;
+        this.validity = validity;
+        this.vector = vector;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * Uint16Array.BYTES_PER_ELEMENT);
+        const items = new Uint16Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBUSmallIntVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBUSmallIntType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            // Checked inline for bulk-write throughput; see dataAccessors.ts.
+            if (!Number.isInteger(value)) {
+                throw new Error(`number is not an integer`);
+            }
+            if (value < 0 || value > 65535) {
+                throw new Error(`number out of uint16 range`);
+            }
+            this.items[itemIndex] = value;
+            this.validity.setItemValid(itemIndex, true);
+        }
+        else {
+            this.validity.setItemValid(itemIndex, false);
+        }
+    }
+    flush() {
+        node_bindings_1.default.copy_data_to_vector(this.vector, 0, this.items.buffer, this.items.byteOffset, this.items.byteLength);
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBUSmallIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBUSmallIntVector = DuckDBUSmallIntVector;

package/lib/vectors/DuckDBUTinyIntVector.d.ts

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

package/lib/vectors/DuckDBUTinyIntVector.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBUTinyIntVector = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBType_1 = require("../DuckDBType");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+const dataAccessors_1 = require("./dataAccessors");
+class DuckDBUTinyIntVector extends DuckDBVector_1.DuckDBVector {
+    items;
+    validity;
+    vector;
+    constructor(items, validity, vector) {
+        super();
+        this.items = items;
+        this.validity = validity;
+        this.vector = vector;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * Uint8Array.BYTES_PER_ELEMENT);
+        const items = new Uint8Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBUTinyIntVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBUTinyIntType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            // Checked inline for bulk-write throughput; see dataAccessors.ts.
+            if (!Number.isInteger(value)) {
+                throw new Error(`number is not an integer`);
+            }
+            if (value < 0 || value > 255) {
+                throw new Error(`number out of uint8 range`);
+            }
+            this.items[itemIndex] = value;
+            this.validity.setItemValid(itemIndex, true);
+        }
+        else {
+            this.validity.setItemValid(itemIndex, false);
+        }
+    }
+    flush() {
+        node_bindings_1.default.copy_data_to_vector(this.vector, 0, this.items.buffer, this.items.byteOffset, this.items.byteLength);
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBUTinyIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBUTinyIntVector = DuckDBUTinyIntVector;

package/lib/vectors/DuckDBUUIDVector.d.ts

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

package/lib/vectors/DuckDBUUIDVector.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBUUIDVector = 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");
+const dataAccessors_1 = require("./dataAccessors");
+class DuckDBUUIDVector extends DuckDBVector_1.DuckDBVector {
+    dataView;
+    validity;
+    vector;
+    _itemCount;
+    constructor(dataView, validity, vector, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this.vector = vector;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBUUIDVector(dataView, validity, vector, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBUUIDType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? values_1.DuckDBUUIDValue.fromStoredHugeInt((0, dataAccessors_1.getInt128)(this.dataView, itemIndex * 16))
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            (0, dataAccessors_1.setInt128)(this.dataView, itemIndex * 16, value.hugeint);
+            this.validity.setItemValid(itemIndex, true);
+        }
+        else {
+            this.validity.setItemValid(itemIndex, false);
+        }
+    }
+    flush() {
+        node_bindings_1.default.copy_data_to_vector(this.vector, 0, this.dataView.buffer, this.dataView.byteOffset, this.dataView.byteLength);
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBUUIDVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset, length), this.vector, length);
+    }
+}
+exports.DuckDBUUIDVector = DuckDBUUIDVector;

package/lib/vectors/DuckDBUnionVector.d.ts

@@ -0,0 +1,17 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBUnionType } from '../DuckDBType';
+import { DuckDBUnionValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBStructVector } from './DuckDBStructVector';
+export declare class DuckDBUnionVector extends DuckDBVector<DuckDBUnionValue> {
+    private readonly unionType;
+    private readonly structVector;
+    constructor(unionType: DuckDBUnionType, structVector: DuckDBStructVector);
+    static fromRawVector(unionType: DuckDBUnionType, vector: duckdb.Vector, itemCount: number): DuckDBUnionVector;
+    get type(): DuckDBUnionType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBUnionValue | null;
+    setItem(itemIndex: number, value: DuckDBUnionValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBUnionVector;
+}

package/lib/vectors/DuckDBUnionVector.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBUnionVector = void 0;
+const DuckDBType_1 = require("../DuckDBType");
+const values_1 = require("../values");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBStructVector_1 = require("./DuckDBStructVector");
+// UNION = STRUCT with first entry named "tag"
+class DuckDBUnionVector extends DuckDBVector_1.DuckDBVector {
+    unionType;
+    structVector;
+    constructor(unionType, structVector) {
+        super();
+        this.unionType = unionType;
+        this.structVector = structVector;
+    }
+    static fromRawVector(unionType, vector, itemCount) {
+        const entryNames = ['tag'];
+        const entryTypes = [DuckDBType_1.DuckDBUTinyIntType.instance];
+        const memberCount = unionType.memberCount;
+        for (let i = 0; i < memberCount; i++) {
+            entryNames.push(unionType.memberTags[i]);
+            entryTypes.push(unionType.memberTypes[i]);
+        }
+        const structVectorType = new DuckDBType_1.DuckDBStructType(entryNames, entryTypes);
+        return new DuckDBUnionVector(unionType, DuckDBStructVector_1.DuckDBStructVector.fromRawVector(structVectorType, vector, itemCount));
+    }
+    get type() {
+        return this.unionType;
+    }
+    get itemCount() {
+        return this.structVector.itemCount;
+    }
+    getItem(itemIndex) {
+        const tagValue = this.structVector.getItemValue(itemIndex, 0);
+        if (tagValue == null) {
+            return null;
+        }
+        const memberIndex = Number(tagValue);
+        const tag = this.unionType.memberTags[memberIndex];
+        const entryIndex = memberIndex + 1;
+        const value = this.structVector.getItemValue(itemIndex, entryIndex);
+        return new values_1.DuckDBUnionValue(tag, value);
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            const memberIndex = this.unionType.memberIndexForTag(value.tag);
+            this.structVector.setItemValue(itemIndex, 0, memberIndex);
+            const entryIndex = memberIndex + 1;
+            this.structVector.setItemValue(itemIndex, entryIndex, value.value);
+            for (let i = 1; i <= this.unionType.memberCount; i++) {
+                if (i !== entryIndex) {
+                    this.structVector.setItemValue(itemIndex, i, null);
+                }
+            }
+        }
+        else {
+            for (let i = 0; i <= this.unionType.memberCount; i++) {
+                this.structVector.setItemValue(itemIndex, i, null);
+            }
+        }
+    }
+    flush() {
+        this.structVector.flush();
+    }
+    slice(offset, length) {
+        return new DuckDBUnionVector(this.unionType, this.structVector.slice(offset, length));
+    }
+}
+exports.DuckDBUnionVector = DuckDBUnionVector;

package/lib/vectors/DuckDBValidity.d.ts

@@ -0,0 +1,12 @@
+import duckdb from '@haybarn/node-bindings';
+export declare class DuckDBValidity {
+    private data;
+    private readonly offset;
+    private readonly itemCount;
+    private constructor();
+    static fromVector(vector: duckdb.Vector, itemCount: number): DuckDBValidity;
+    itemValid(itemIndex: number): boolean;
+    setItemValid(itemIndex: number, valid: boolean): void;
+    flush(vector: duckdb.Vector): void;
+    slice(offset: number, itemCount: number): DuckDBValidity;
+}

package/lib/vectors/DuckDBValidity.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBValidity = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+// This version of DuckDBValidity is almost 10x slower.
+// class DuckDBValidity {
+//   private readonly validity_pointer: ddb.uint64_pointer;
+//   private readonly offset: number;
+//   private constructor(validity_pointer: ddb.uint64_pointer, offset: number = 0) {
+//     this.validity_pointer = validity_pointer;
+//     this.offset = offset;
+//   }
+//   public static fromVector(vector: ddb.duckdb_vector, itemCount: number, offset: number = 0): DuckDBValidity {
+//     const validity_pointer = ddb.duckdb_vector_get_validity(vector);
+//     return new DuckDBValidity(validity_pointer, offset);
+//   }
+//   public itemValid(itemIndex: number): boolean {
+//     return ddb.duckdb_validity_row_is_valid(this.validity_pointer, this.offset + itemIndex);
+//   }
+//   public slice(offset: number): DuckDBValidity {
+//     return new DuckDBValidity(this.validity_pointer, this.offset + offset);
+//   }
+// }
+class DuckDBValidity {
+    data;
+    offset;
+    itemCount;
+    constructor(data, offset, itemCount) {
+        this.data = data;
+        this.offset = offset;
+        this.itemCount = itemCount;
+    }
+    static fromVector(vector, itemCount) {
+        const uint64Count = Math.ceil(itemCount / 64);
+        const bytes = node_bindings_1.default.vector_get_validity(vector, uint64Count * 8);
+        if (!bytes) {
+            return new DuckDBValidity(null, 0, itemCount);
+        }
+        const bigints = new BigUint64Array(bytes.buffer, bytes.byteOffset, uint64Count);
+        return new DuckDBValidity(bigints, 0, itemCount);
+    }
+    itemValid(itemIndex) {
+        if (!this.data) {
+            return true;
+        }
+        const bit = this.offset + itemIndex;
+        return ((this.data[Math.floor(bit / 64)] & (BigInt(1) << BigInt(bit % 64))) !==
+            BigInt(0));
+    }
+    setItemValid(itemIndex, valid) {
+        if (!this.data && !valid) {
+            // An item is being set to invalid and we don't have a data buffer, so create it. If an item is being set to valid
+            // and we don't have a data buffer, then there's nothing to do; a null data buffer indicates all items are valid.
+            const uint64Count = Math.ceil(this.itemCount / 64);
+            const buffer = new ArrayBuffer(uint64Count * 8);
+            this.data = new BigUint64Array(buffer, 0, uint64Count);
+            // Initialize to all items to valid.
+            for (let i = 0; i < this.data.length; i++) {
+                this.data[i] = 0xffffffffffffffffn;
+            }
+        }
+        if (this.data) {
+            const bit = this.offset + itemIndex;
+            const uint64Index = Math.floor(bit / 64);
+            const uint64WithBitSet = BigInt(1) << BigInt(bit % 64);
+            if (valid) {
+                if ((this.data[uint64Index] & uint64WithBitSet) === 0n) {
+                    this.data[uint64Index] |= uint64WithBitSet;
+                }
+            }
+            else {
+                if ((this.data[uint64Index] & uint64WithBitSet) !== 0n) {
+                    this.data[uint64Index] &= ~uint64WithBitSet;
+                }
+            }
+        }
+    }
+    flush(vector) {
+        if (this.data) {
+            node_bindings_1.default.vector_ensure_validity_writable(vector);
+            node_bindings_1.default.copy_data_to_vector_validity(vector, 0, this.data.buffer, this.data.byteOffset, this.data.byteLength);
+        }
+    }
+    slice(offset, itemCount) {
+        return new DuckDBValidity(this.data, this.offset + offset, itemCount);
+    }
+}
+exports.DuckDBValidity = DuckDBValidity;

package/lib/vectors/DuckDBVarCharVector.d.ts

@@ -0,0 +1,21 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBVarCharType } from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBVarCharVector extends DuckDBVector<string> {
+    private readonly dataView;
+    private readonly validity;
+    private readonly vector;
+    private readonly itemOffset;
+    private readonly _itemCount;
+    private readonly itemCache;
+    private readonly itemCacheDirty;
+    constructor(dataView: DataView, validity: DuckDBValidity, vector: duckdb.Vector, itemOffset: number, itemCount: number);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBVarCharVector;
+    get type(): DuckDBVarCharType;
+    get itemCount(): number;
+    getItem(itemIndex: number): string | null;
+    setItem(itemIndex: number, value: string | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBVarCharVector;
+}

package/lib/vectors/DuckDBVarCharVector.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBVarCharVector = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBType_1 = require("../DuckDBType");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+const dataAccessors_1 = require("./dataAccessors");
+class DuckDBVarCharVector extends DuckDBVector_1.DuckDBVector {
+    dataView;
+    validity;
+    vector;
+    itemOffset;
+    _itemCount;
+    itemCache;
+    itemCacheDirty;
+    constructor(dataView, validity, vector, itemOffset, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this.vector = vector;
+        this.itemOffset = itemOffset;
+        this._itemCount = itemCount;
+        this.itemCache = [];
+        this.itemCacheDirty = [];
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = (0, dataAccessors_1.vectorData)(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBVarCharVector(dataView, validity, vector, 0, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBVarCharType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        const cachedItem = this.itemCache[itemIndex];
+        if (cachedItem !== undefined) {
+            return cachedItem;
+        }
+        const item = this.validity.itemValid(itemIndex)
+            ? (0, dataAccessors_1.getString)(this.dataView, itemIndex * 16)
+            : null;
+        this.itemCache[itemIndex] = item;
+        return item;
+    }
+    setItem(itemIndex, value) {
+        this.itemCache[itemIndex] = value;
+        this.validity.setItemValid(itemIndex, value != null);
+        this.itemCacheDirty[itemIndex] = true;
+    }
+    flush() {
+        for (let itemIndex = 0; itemIndex < this._itemCount; itemIndex++) {
+            if (this.itemCacheDirty[itemIndex]) {
+                const cachedItem = this.itemCache[itemIndex];
+                if (cachedItem !== undefined && cachedItem !== null) {
+                    node_bindings_1.default.vector_assign_string_element(this.vector, this.itemOffset + itemIndex, cachedItem);
+                }
+                this.itemCacheDirty[itemIndex] = false;
+            }
+        }
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBVarCharVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset, length), this.vector, offset, length);
+    }
+}
+exports.DuckDBVarCharVector = DuckDBVarCharVector;

package/lib/vectors/DuckDBVariantVector.d.ts

@@ -0,0 +1,42 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBVariantType } from '../DuckDBType';
+import { DuckDBVariantValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBStructVector } from './DuckDBStructVector';
+export declare class DuckDBVariantVector extends DuckDBVector<DuckDBVariantValue> {
+    private readonly structVec;
+    private readonly keysList;
+    private readonly childrenList;
+    private readonly valuesList;
+    private readonly dataBlob;
+    private readonly keysEntry;
+    private readonly keysIdxVec;
+    private readonly valuesIdxVec;
+    private readonly typeIdVec;
+    private readonly byteOffsetVec;
+    constructor(structVec: DuckDBStructVector);
+    static fromRawVector(vector: duckdb.Vector, itemCount: number): DuckDBVariantVector;
+    get type(): DuckDBVariantType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBVariantValue | null;
+    setItem(_itemIndex: number, value: DuckDBVariantValue | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBVariantVector;
+    /**
+     * Decode one variant node identified by its row-local `valueIndex`
+     * (an index into the row's `values` list). Per-row state is bundled in
+     * `row`: the data blob plus the row-local list slice extents and the
+     * absolute backing-array offsets they begin at. All recursive calls
+     * share the same `row`; only `valueIndex` changes.
+     *
+     * Returns both the decoded value and the `DuckDBType` corresponding to
+     * the node's on-disk tag, so the top-level caller can attach the type
+     * to the resulting `DuckDBVariantValue` for round-trip fidelity.
+     *
+     * Throws if any index decoded from the blob falls outside its row-local
+     * list slice — guards against malformed or hostile VARIANT payloads.
+     */
+    private decodeNode;
+    /** Bounds-check an OBJECT / ARRAY's `[childrenIdx, childrenIdx+childCount)` range. */
+    private checkChildrenSlice;
+}