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

package/lib/vectors/DuckDBTimestampSecondsVector.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.DuckDBTimestampSecondsVector = 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 DuckDBTimestampSecondsVector 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 * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimestampSecondsVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimestampSecondsType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBTimestampSecondsValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            // Checked inline for bulk-write throughput; see dataAccessors.ts.
+            if (BigInt.asIntN(64, value.seconds) !== value.seconds) {
+                throw new Error(`bigint out of int64 range`);
+            }
+            this.items[itemIndex] = value.seconds;
+            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 DuckDBTimestampSecondsVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBTimestampSecondsVector = DuckDBTimestampSecondsVector;

package/lib/vectors/DuckDBTimestampTZNanosecondsVector.d.ts

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

package/lib/vectors/DuckDBTimestampTZNanosecondsVector.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.DuckDBTimestampTZNanosecondsVector = 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 DuckDBTimestampTZNanosecondsVector 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 * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimestampTZNanosecondsVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimestampTZNanosecondsType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBTimestampTZNanosecondsValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            // Checked inline for bulk-write throughput; see dataAccessors.ts.
+            if (BigInt.asIntN(64, value.nanos) !== value.nanos) {
+                throw new Error(`bigint out of int64 range`);
+            }
+            this.items[itemIndex] = value.nanos;
+            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 DuckDBTimestampTZNanosecondsVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBTimestampTZNanosecondsVector = DuckDBTimestampTZNanosecondsVector;

package/lib/vectors/DuckDBTimestampTZVector.d.ts

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

package/lib/vectors/DuckDBTimestampTZVector.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.DuckDBTimestampTZVector = 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 DuckDBTimestampTZVector 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 * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimestampTZVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimestampTZType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBTimestampTZValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            // Checked inline for bulk-write throughput; see dataAccessors.ts.
+            if (BigInt.asIntN(64, value.micros) !== value.micros) {
+                throw new Error(`bigint out of int64 range`);
+            }
+            this.items[itemIndex] = value.micros;
+            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 DuckDBTimestampTZVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBTimestampTZVector = DuckDBTimestampTZVector;

package/lib/vectors/DuckDBTimestampVector.d.ts

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

package/lib/vectors/DuckDBTimestampVector.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.DuckDBTimestampVector = 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 DuckDBTimestampVector 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 * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimestampVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimestampType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? new values_1.DuckDBTimestampValue(this.items[itemIndex])
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            // Checked inline for bulk-write throughput; see dataAccessors.ts.
+            if (BigInt.asIntN(64, value.micros) !== value.micros) {
+                throw new Error(`bigint out of int64 range`);
+            }
+            this.items[itemIndex] = value.micros;
+            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 DuckDBTimestampVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBTimestampVector = DuckDBTimestampVector;

package/lib/vectors/DuckDBTinyIntVector.d.ts

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

package/lib/vectors/DuckDBTinyIntVector.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.DuckDBTinyIntVector = 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 DuckDBTinyIntVector 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 * Int8Array.BYTES_PER_ELEMENT);
+        const items = new Int8Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTinyIntVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTinyIntType.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 < -128 || value > 127) {
+                throw new Error(`number out of int8 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 DuckDBTinyIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBTinyIntVector = DuckDBTinyIntVector;

package/lib/vectors/DuckDBTupleVector.d.ts

@@ -0,0 +1,26 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBStructType } from '../DuckDBType';
+import { DuckDBTupleValue, DuckDBValue } from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+/**
+ * A vector of a tuple type: a STRUCT whose entry names are all empty (see
+ * `DuckDBStructType.isTuple`). Items are `DuckDBTupleValue`s.
+ */
+export declare class DuckDBTupleVector extends DuckDBVector<DuckDBTupleValue> {
+    private readonly tupleType;
+    private readonly _itemCount;
+    private readonly entryVectors;
+    private readonly validity;
+    private readonly vector;
+    constructor(tupleType: DuckDBStructType, itemCount: number, entryVectors: readonly DuckDBVector[], validity: DuckDBValidity, vector: duckdb.Vector);
+    static fromRawVector(tupleType: DuckDBStructType, vector: duckdb.Vector, itemCount: number): DuckDBTupleVector;
+    get type(): DuckDBStructType;
+    get itemCount(): number;
+    getItem(itemIndex: number): DuckDBTupleValue | null;
+    getItemValue(itemIndex: number, entryIndex: number): DuckDBValue | null;
+    setItem(itemIndex: number, value: DuckDBTupleValue | null): void;
+    setItemValue(itemIndex: number, entryIndex: number, value: DuckDBValue): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBTupleVector;
+}

package/lib/vectors/DuckDBTupleVector.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.DuckDBTupleVector = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const values_1 = require("../values");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBValidity_1 = require("./DuckDBValidity");
+/**
+ * A vector of a tuple type: a STRUCT whose entry names are all empty (see
+ * `DuckDBStructType.isTuple`). Items are `DuckDBTupleValue`s.
+ */
+class DuckDBTupleVector extends DuckDBVector_1.DuckDBVector {
+    tupleType;
+    _itemCount;
+    entryVectors;
+    validity;
+    vector;
+    constructor(tupleType, itemCount, entryVectors, validity, vector) {
+        super();
+        this.tupleType = tupleType;
+        this._itemCount = itemCount;
+        this.entryVectors = entryVectors;
+        this.validity = validity;
+        this.vector = vector;
+    }
+    static fromRawVector(tupleType, vector, itemCount) {
+        const entryCount = tupleType.entryCount;
+        const entryVectors = [];
+        for (let i = 0; i < entryCount; i++) {
+            const child_vector = node_bindings_1.default.struct_vector_get_child(vector, i);
+            entryVectors.push(DuckDBVector_1.DuckDBVector.create(child_vector, itemCount, tupleType.entryTypes[i]));
+        }
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTupleVector(tupleType, itemCount, entryVectors, validity, vector);
+    }
+    get type() {
+        return this.tupleType;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        return new values_1.DuckDBTupleValue(this.entryVectors.map((entryVector) => entryVector.getItem(itemIndex)));
+    }
+    getItemValue(itemIndex, entryIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        return this.entryVectors[entryIndex].getItem(itemIndex);
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            if (!(value instanceof values_1.DuckDBTupleValue)) {
+                throw new Error(`Expected DuckDBTupleValue for ${this.tupleType}`);
+            }
+            const entryCount = this.tupleType.entryCount;
+            if (value.items.length !== entryCount) {
+                throw new Error(`Expected ${entryCount} items for ${this.tupleType}, got ${value.items.length}`);
+            }
+            for (let i = 0; i < entryCount; i++) {
+                this.entryVectors[i].setItem(itemIndex, value.items[i]);
+            }
+            this.validity.setItemValid(itemIndex, true);
+        }
+        else {
+            for (const entryVector of this.entryVectors) {
+                entryVector.setItem(itemIndex, null);
+            }
+            this.validity.setItemValid(itemIndex, false);
+        }
+    }
+    setItemValue(itemIndex, entryIndex, value) {
+        return this.entryVectors[entryIndex].setItem(itemIndex, value);
+    }
+    flush() {
+        for (const entryVector of this.entryVectors) {
+            entryVector.flush();
+        }
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBTupleVector(this.tupleType, length, this.entryVectors.map((entryVector) => entryVector.slice(offset, length)), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBTupleVector = DuckDBTupleVector;

package/lib/vectors/DuckDBUBigIntVector.d.ts

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

package/lib/vectors/DuckDBUBigIntVector.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBUBigIntVector = 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 DuckDBUBigIntVector 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 * BigUint64Array.BYTES_PER_ELEMENT);
+        const items = new BigUint64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity_1.DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBUBigIntVector(items, validity, vector);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBUBigIntType.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 (BigInt.asUintN(64, value) !== value) {
+                throw new Error(`bigint out of uint64 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 DuckDBUBigIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset, length), this.vector);
+    }
+}
+exports.DuckDBUBigIntVector = DuckDBUBigIntVector;

package/lib/vectors/DuckDBUHugeIntVector.d.ts

@@ -0,0 +1,19 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBUHugeIntType } from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+export declare class DuckDBUHugeIntVector extends DuckDBVector<bigint> {
+    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): DuckDBUHugeIntVector;
+    get type(): DuckDBUHugeIntType;
+    get itemCount(): number;
+    getItem(itemIndex: number): bigint | null;
+    getDouble(itemIndex: number): number | null;
+    setItem(itemIndex: number, value: bigint | null): void;
+    flush(): void;
+    slice(offset: number, length: number): DuckDBUHugeIntVector;
+}

package/lib/vectors/DuckDBUHugeIntVector.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBUHugeIntVector = 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 DuckDBUHugeIntVector 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 DuckDBUHugeIntVector(dataView, validity, vector, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBUHugeIntType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? (0, dataAccessors_1.getUInt128)(this.dataView, itemIndex * 16)
+            : null;
+    }
+    getDouble(itemIndex) {
+        return this.validity.itemValid(itemIndex)
+            ? node_bindings_1.default.uhugeint_to_double((0, dataAccessors_1.getUInt128)(this.dataView, itemIndex * 16))
+            : null;
+    }
+    setItem(itemIndex, value) {
+        if (value != null) {
+            (0, dataAccessors_1.setUInt128)(this.dataView, itemIndex * 16, 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.dataView.buffer, this.dataView.byteOffset, this.dataView.byteLength);
+        this.validity.flush(this.vector);
+    }
+    slice(offset, length) {
+        return new DuckDBUHugeIntVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset, length), this.vector, length);
+    }
+}
+exports.DuckDBUHugeIntVector = DuckDBUHugeIntVector;