@duckdb/node-api 1.1.2-alpha.1

package/lib/DuckDBVector.js

@@ -0,0 +1,1676 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBVarIntVector = exports.DuckDBTimestampTZVector = exports.DuckDBTimeTZVector = exports.DuckDBTimeTZValue = exports.DuckDBBitVector = exports.DuckDBBitValue = exports.DuckDBUnionVector = exports.DuckDBUUIDVector = exports.DuckDBArrayVector = exports.DuckDBMapVector = exports.DuckDBStructVector = exports.DuckDBListVector = exports.DuckDBEnum4Vector = exports.DuckDBEnum2Vector = exports.DuckDBEnum1Vector = exports.DuckDBTimestampNanosecondsVector = exports.DuckDBTimestampMillisecondsVector = exports.DuckDBTimestampSecondsVector = exports.DuckDBDecimal16Vector = exports.DuckDBDecimal8Vector = exports.DuckDBDecimal4Vector = exports.DuckDBDecimal2Vector = exports.DuckDBBlobVector = exports.DuckDBVarCharVector = exports.DuckDBUHugeIntVector = exports.DuckDBHugeIntVector = exports.DuckDBIntervalVector = exports.DuckDBInterval = exports.DuckDBTimeVector = exports.DuckDBDateVector = exports.DuckDBTimestampVector = exports.DuckDBDoubleVector = exports.DuckDBFloatVector = exports.DuckDBUBigIntVector = exports.DuckDBUIntegerVector = exports.DuckDBUSmallIntVector = exports.DuckDBUTinyIntVector = exports.DuckDBBigIntVector = exports.DuckDBIntegerVector = exports.DuckDBSmallIntVector = exports.DuckDBTinyIntVector = exports.DuckDBBooleanVector = exports.DuckDBVector = exports.DuckDBLargeDecimal = exports.DuckDBSmallDecimal = void 0;
+const node_bindings_1 = __importDefault(require("@duckdb/node-bindings"));
+const os_1 = __importDefault(require("os"));
+const DuckDBLogicalType_1 = require("./DuckDBLogicalType");
+const DuckDBType_1 = require("./DuckDBType");
+const DuckDBTypeId_1 = require("./DuckDBTypeId");
+const littleEndian = os_1.default.endianness() === 'LE';
+// function getInt8(dataView: DataView, offset: number): number {
+//   return dataView.getInt8(offset);
+// }
+function getUInt8(dataView, offset) {
+    return dataView.getUint8(offset);
+}
+function getInt16(dataView, offset) {
+    return dataView.getInt16(offset, littleEndian);
+}
+function getUInt16(dataView, offset) {
+    return dataView.getUint16(offset, littleEndian);
+}
+function getInt32(dataView, offset) {
+    return dataView.getInt32(offset, littleEndian);
+}
+function getUInt32(dataView, offset) {
+    return dataView.getUint32(offset, littleEndian);
+}
+function getInt64(dataView, offset) {
+    return dataView.getBigInt64(offset, littleEndian);
+}
+function getUInt64(dataView, offset) {
+    return dataView.getBigUint64(offset, littleEndian);
+}
+// function getFloat32(dataView: DataView, offset: number): number {
+//   return dataView.getFloat32(offset, littleEndian);
+// }
+// function getFloat64(dataView: DataView, offset: number): number {
+//   return dataView.getFloat64(offset, littleEndian);
+// }
+function getInt128(dataView, offset) {
+    const lower = getUInt64(dataView, offset);
+    const upper = getInt64(dataView, offset + 8);
+    return (upper << BigInt(64)) + lower;
+}
+function getUInt128(dataView, offset) {
+    const lower = getUInt64(dataView, offset);
+    const upper = getUInt64(dataView, offset + 8);
+    return BigInt.asUintN(64, upper) << BigInt(64) | BigInt.asUintN(64, lower);
+}
+function getStringBytes(dataView, offset) {
+    const lengthInBytes = dataView.getUint32(offset, true);
+    if (lengthInBytes <= 12) {
+        return new Uint8Array(dataView.buffer, dataView.byteOffset + offset + 4, lengthInBytes);
+    }
+    else {
+        return node_bindings_1.default.get_data_from_pointer(dataView.buffer, dataView.byteOffset + offset + 8, lengthInBytes);
+    }
+}
+const textDecoder = new TextDecoder();
+function getString(dataView, offset) {
+    const stringBytes = getStringBytes(dataView, offset);
+    if (!stringBytes) {
+        // should we throw here instead?
+        return null;
+    }
+    return textDecoder.decode(stringBytes);
+}
+function getBuffer(dataView, offset) {
+    const stringBytes = getStringBytes(dataView, offset);
+    if (!stringBytes) {
+        // should we throw here instead?
+        return null;
+    }
+    return Buffer.from(stringBytes);
+}
+function getVarIntFromBytes(bytes) {
+    const firstByte = bytes[0];
+    const positive = (firstByte & 0x80) > 0;
+    const uint64Mask = positive ? 0n : 0xffffffffffffffffn;
+    const uint8Mask = positive ? 0 : 0xff;
+    const dv = new DataView(bytes.buffer, bytes.byteOffset + 3, bytes.byteLength - 3);
+    const lastUint64Offset = dv.byteLength - 8;
+    let offset = 0;
+    let result = 0n;
+    while (offset <= lastUint64Offset) {
+        result = (result << 64n) | (dv.getBigUint64(offset) ^ uint64Mask);
+        offset += 8;
+    }
+    while (offset < dv.byteLength) {
+        result = (result << 8n) | BigInt(dv.getUint8(offset) ^ uint8Mask);
+        offset += 1;
+    }
+    return positive ? result : -result;
+}
+function getBoolean1(dataView, offset) {
+    return getUInt8(dataView, offset) !== 0;
+}
+function getBoolean2(dataView, offset) {
+    return getUInt16(dataView, offset) !== 0;
+}
+function getBoolean4(dataView, offset) {
+    return getUInt32(dataView, offset) !== 0;
+}
+function getBoolean8(dataView, offset) {
+    return getUInt64(dataView, offset) !== BigInt(0);
+}
+function makeGetBoolean() {
+    switch (node_bindings_1.default.sizeof_bool) {
+        case 1:
+            return getBoolean1;
+        case 2:
+            return getBoolean2;
+        case 4:
+            return getBoolean4;
+        case 8:
+            return getBoolean8;
+        default:
+            throw new Error(`Unsupported boolean size: ${node_bindings_1.default.sizeof_bool}`);
+    }
+}
+const getBoolean = makeGetBoolean();
+class DuckDBSmallDecimal {
+    scaledValue;
+    type;
+    constructor(scaledValue, type) {
+        this.scaledValue = scaledValue;
+        this.type = type;
+    }
+}
+exports.DuckDBSmallDecimal = DuckDBSmallDecimal;
+class DuckDBLargeDecimal {
+    scaledValue;
+    type;
+    constructor(scaledValue, type) {
+        this.scaledValue = scaledValue;
+        this.type = type;
+    }
+}
+exports.DuckDBLargeDecimal = DuckDBLargeDecimal;
+function getDecimal2(dataView, offset, type) {
+    const scaledValue = getInt16(dataView, offset);
+    return new DuckDBSmallDecimal(scaledValue, type);
+}
+function getDecimal4(dataView, offset, type) {
+    const scaledValue = getInt32(dataView, offset);
+    return new DuckDBSmallDecimal(scaledValue, type);
+}
+function getDecimal8(dataView, offset, type) {
+    const scaledValue = getInt64(dataView, offset);
+    return new DuckDBLargeDecimal(scaledValue, type);
+}
+function getDecimal16(dataView, offset, type) {
+    const scaledValue = getInt128(dataView, offset);
+    return new DuckDBLargeDecimal(scaledValue, type);
+}
+function vectorData(vector, byteCount) {
+    return node_bindings_1.default.vector_get_data(vector, byteCount);
+}
+// 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;
+    constructor(data, offset) {
+        this.data = data;
+        this.offset = offset;
+    }
+    static fromVector(vector, itemCount) {
+        const bigintCount = Math.ceil(itemCount / 64);
+        const bytes = node_bindings_1.default.vector_get_validity(vector, bigintCount * 8);
+        const bigints = new BigUint64Array(bytes.buffer, bytes.byteOffset, bigintCount);
+        return new DuckDBValidity(bigints, 0);
+    }
+    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);
+    }
+    slice(offset) {
+        return new DuckDBValidity(this.data, this.offset + offset);
+    }
+}
+class DuckDBVector {
+    static standardSize() {
+        return node_bindings_1.default.vector_size();
+    }
+    static create(vector, itemCount, knownType) {
+        const vectorType = knownType ? knownType : DuckDBLogicalType_1.DuckDBLogicalType.consumeAsType(node_bindings_1.default.vector_get_column_type(vector));
+        switch (vectorType.typeId) {
+            case DuckDBTypeId_1.DuckDBTypeId.BOOLEAN:
+                return DuckDBBooleanVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.TINYINT:
+                return DuckDBTinyIntVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.SMALLINT:
+                return DuckDBSmallIntVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.INTEGER:
+                return DuckDBIntegerVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.BIGINT:
+                return DuckDBBigIntVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.UTINYINT:
+                return DuckDBUTinyIntVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.USMALLINT:
+                return DuckDBUSmallIntVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.UINTEGER:
+                return DuckDBUIntegerVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.UBIGINT:
+                return DuckDBUBigIntVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.FLOAT:
+                return DuckDBFloatVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.DOUBLE:
+                return DuckDBDoubleVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP:
+                return DuckDBTimestampVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.DATE:
+                return DuckDBDateVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.TIME:
+                return DuckDBTimeVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.INTERVAL:
+                return DuckDBIntervalVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.HUGEINT:
+                return DuckDBHugeIntVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.UHUGEINT:
+                return DuckDBUHugeIntVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.VARCHAR:
+                return DuckDBVarCharVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.BLOB:
+                return DuckDBBlobVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.DECIMAL:
+                if (vectorType instanceof DuckDBType_1.DuckDBDecimalType) {
+                    const { width } = vectorType;
+                    if (width <= 0) {
+                        throw new Error(`DECIMAL width not positive: ${width}`);
+                    }
+                    else if (width <= 4) {
+                        return DuckDBDecimal2Vector.fromRawVector(vectorType, vector, itemCount);
+                    }
+                    else if (width <= 9) {
+                        return DuckDBDecimal4Vector.fromRawVector(vectorType, vector, itemCount);
+                    }
+                    else if (width <= 18) {
+                        return DuckDBDecimal8Vector.fromRawVector(vectorType, vector, itemCount);
+                    }
+                    else if (width <= 38) {
+                        return DuckDBDecimal16Vector.fromRawVector(vectorType, vector, itemCount);
+                    }
+                    else {
+                        throw new Error(`DECIMAL width too large: ${width}`);
+                    }
+                }
+                throw new Error('DuckDBType has DECIMAL type id but is not an instance of DuckDBDecimalType');
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_S:
+                return DuckDBTimestampSecondsVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_MS:
+                return DuckDBTimestampMillisecondsVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_NS:
+                return DuckDBTimestampNanosecondsVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.ENUM:
+                if (vectorType instanceof DuckDBType_1.DuckDBEnumType) {
+                    const { internalTypeId } = vectorType;
+                    switch (internalTypeId) {
+                        case DuckDBTypeId_1.DuckDBTypeId.UTINYINT:
+                            return DuckDBEnum1Vector.fromRawVector(vectorType, vector, itemCount);
+                        case DuckDBTypeId_1.DuckDBTypeId.USMALLINT:
+                            return DuckDBEnum2Vector.fromRawVector(vectorType, vector, itemCount);
+                        case DuckDBTypeId_1.DuckDBTypeId.UINTEGER:
+                            return DuckDBEnum4Vector.fromRawVector(vectorType, vector, itemCount);
+                        default:
+                            throw new Error(`unsupported ENUM internal type: ${internalTypeId}`);
+                    }
+                }
+                throw new Error('DuckDBType has ENUM type id but is not an instance of DuckDBEnumType');
+            case DuckDBTypeId_1.DuckDBTypeId.LIST:
+                if (vectorType instanceof DuckDBType_1.DuckDBListType) {
+                    return DuckDBListVector.fromRawVector(vectorType, vector, itemCount);
+                }
+                throw new Error('DuckDBType has LIST type id but is not an instance of DuckDBListType');
+            case DuckDBTypeId_1.DuckDBTypeId.STRUCT:
+                if (vectorType instanceof DuckDBType_1.DuckDBStructType) {
+                    return DuckDBStructVector.fromRawVector(vectorType, vector, itemCount);
+                }
+                throw new Error('DuckDBType has STRUCT type id but is not an instance of DuckDBStructType');
+            case DuckDBTypeId_1.DuckDBTypeId.MAP:
+                if (vectorType instanceof DuckDBType_1.DuckDBMapType) {
+                    return DuckDBMapVector.fromRawVector(vectorType, vector, itemCount);
+                }
+                throw new Error('DuckDBType has MAP type id but is not an instance of DuckDBMapType');
+            case DuckDBTypeId_1.DuckDBTypeId.ARRAY:
+                if (vectorType instanceof DuckDBType_1.DuckDBArrayType) {
+                    return DuckDBArrayVector.fromRawVector(vectorType, vector, itemCount);
+                }
+                throw new Error('DuckDBType has ARRAY type id but is not an instance of DuckDBArrayType');
+            case DuckDBTypeId_1.DuckDBTypeId.UUID:
+                return DuckDBUUIDVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.UNION:
+                if (vectorType instanceof DuckDBType_1.DuckDBUnionType) {
+                    return DuckDBUnionVector.fromRawVector(vectorType, vector, itemCount);
+                }
+                throw new Error('DuckDBType has UNION type id but is not an instance of DuckDBUnionType');
+            case DuckDBTypeId_1.DuckDBTypeId.BIT:
+                return DuckDBBitVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.TIME_TZ:
+                return DuckDBTimeTZVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_TZ:
+                return DuckDBTimestampTZVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.ANY:
+                throw new Error(`Invalid vector type: ANY`);
+            case DuckDBTypeId_1.DuckDBTypeId.VARINT:
+                return DuckDBVarIntVector.fromRawVector(vector, itemCount);
+            case DuckDBTypeId_1.DuckDBTypeId.SQLNULL:
+                throw new Error(`Invalid vector type: SQLNULL`);
+            default:
+                throw new Error(`Invalid type id: ${vectorType.typeId}`);
+        }
+    }
+}
+exports.DuckDBVector = DuckDBVector;
+class DuckDBBooleanVector extends DuckDBVector {
+    dataView;
+    validity;
+    _itemCount;
+    constructor(dataView, validity, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * node_bindings_1.default.sizeof_bool);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBBooleanVector(dataView, validity, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBBooleanType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? getBoolean(this.dataView, itemIndex * node_bindings_1.default.sizeof_bool) : null;
+    }
+    slice(offset, length) {
+        return new DuckDBBooleanVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * node_bindings_1.default.sizeof_bool, length * node_bindings_1.default.sizeof_bool), this.validity.slice(offset), length);
+    }
+}
+exports.DuckDBBooleanVector = DuckDBBooleanVector;
+class DuckDBTinyIntVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * Int8Array.BYTES_PER_ELEMENT);
+        const items = new Int8Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTinyIntVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTinyIntType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBTinyIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBTinyIntVector = DuckDBTinyIntVector;
+class DuckDBSmallIntVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * Int16Array.BYTES_PER_ELEMENT);
+        const items = new Int16Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBSmallIntVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBSmallIntType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBSmallIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBSmallIntVector = DuckDBSmallIntVector;
+class DuckDBIntegerVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * Int32Array.BYTES_PER_ELEMENT);
+        const items = new Int32Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBIntegerVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBIntegerType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBIntegerVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBIntegerVector = DuckDBIntegerVector;
+class DuckDBBigIntVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBBigIntVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBBigIntType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBBigIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBBigIntVector = DuckDBBigIntVector;
+class DuckDBUTinyIntVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * Uint8Array.BYTES_PER_ELEMENT);
+        const items = new Uint8Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBUTinyIntVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBUTinyIntType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBUTinyIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBUTinyIntVector = DuckDBUTinyIntVector;
+class DuckDBUSmallIntVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * Uint16Array.BYTES_PER_ELEMENT);
+        const items = new Uint16Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBUSmallIntVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBUSmallIntType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBUSmallIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBUSmallIntVector = DuckDBUSmallIntVector;
+class DuckDBUIntegerVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * Uint32Array.BYTES_PER_ELEMENT);
+        const items = new Uint32Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBUIntegerVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBUIntegerType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBUIntegerVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBUIntegerVector = DuckDBUIntegerVector;
+class DuckDBUBigIntVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * BigUint64Array.BYTES_PER_ELEMENT);
+        const items = new BigUint64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBUBigIntVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBUBigIntType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBUBigIntVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBUBigIntVector = DuckDBUBigIntVector;
+class DuckDBFloatVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * Float32Array.BYTES_PER_ELEMENT);
+        const items = new Float32Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBFloatVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBFloatType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBFloatVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBFloatVector = DuckDBFloatVector;
+class DuckDBDoubleVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * Float64Array.BYTES_PER_ELEMENT);
+        const items = new Float64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBDoubleVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBDoubleType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBDoubleVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBDoubleVector = DuckDBDoubleVector;
+class DuckDBTimestampVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimestampVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimestampType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBTimestampVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBTimestampVector = DuckDBTimestampVector;
+class DuckDBDateVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * Int32Array.BYTES_PER_ELEMENT);
+        const items = new Int32Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBDateVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBDateType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBDateVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBDateVector = DuckDBDateVector;
+class DuckDBTimeVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimeVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimeType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBTimeVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBTimeVector = DuckDBTimeVector;
+class DuckDBInterval {
+    months;
+    days;
+    micros;
+    constructor(months, days, micros) {
+        this.months = months;
+        this.days = days;
+        this.micros = micros;
+    }
+}
+exports.DuckDBInterval = DuckDBInterval;
+class DuckDBIntervalVector extends DuckDBVector {
+    dataView;
+    validity;
+    _itemCount;
+    constructor(dataView, validity, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBIntervalVector(dataView, validity, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBIntervalType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        const itemStart = itemIndex * 16;
+        const months = getInt32(this.dataView, itemStart);
+        const days = getInt32(this.dataView, itemStart + 4);
+        const micros = getInt64(this.dataView, itemStart + 8);
+        return new DuckDBInterval(months, days, micros);
+    }
+    slice(offset, length) {
+        return new DuckDBIntervalVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset), length);
+    }
+}
+exports.DuckDBIntervalVector = DuckDBIntervalVector;
+class DuckDBHugeIntVector extends DuckDBVector {
+    dataView;
+    validity;
+    _itemCount;
+    constructor(dataView, validity, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBHugeIntVector(dataView, validity, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBHugeIntType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? getInt128(this.dataView, itemIndex * 16) : null;
+    }
+    slice(offset, length) {
+        return new DuckDBHugeIntVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset), length);
+    }
+}
+exports.DuckDBHugeIntVector = DuckDBHugeIntVector;
+class DuckDBUHugeIntVector extends DuckDBVector {
+    dataView;
+    validity;
+    _itemCount;
+    constructor(dataView, validity, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBUHugeIntVector(dataView, validity, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBUHugeIntType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? getUInt128(this.dataView, itemIndex * 16) : null;
+    }
+    slice(offset, length) {
+        return new DuckDBUHugeIntVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset), length);
+    }
+}
+exports.DuckDBUHugeIntVector = DuckDBUHugeIntVector;
+class DuckDBVarCharVector extends DuckDBVector {
+    dataView;
+    validity;
+    _itemCount;
+    constructor(dataView, validity, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBVarCharVector(dataView, validity, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBVarCharType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? getString(this.dataView, itemIndex * 16) : null;
+    }
+    slice(offset, length) {
+        return new DuckDBVarCharVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset), length);
+    }
+}
+exports.DuckDBVarCharVector = DuckDBVarCharVector;
+class DuckDBBlobVector extends DuckDBVector {
+    dataView;
+    validity;
+    _itemCount;
+    constructor(dataView, validity, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBBlobVector(dataView, validity, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBBlobType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? getBuffer(this.dataView, itemIndex * 16) : null;
+    }
+    slice(offset, length) {
+        return new DuckDBBlobVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset), length);
+    }
+}
+exports.DuckDBBlobVector = DuckDBBlobVector;
+class DuckDBDecimal2Vector extends DuckDBVector {
+    decimalType;
+    dataView;
+    validity;
+    _itemCount;
+    constructor(decimalType, dataView, validity, itemCount) {
+        super();
+        this.decimalType = decimalType;
+        this.dataView = dataView;
+        this.validity = validity;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(decimalType, vector, itemCount) {
+        const data = vectorData(vector, itemCount * 2);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBDecimal2Vector(decimalType, dataView, validity, itemCount);
+    }
+    get type() {
+        return this.decimalType;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? getDecimal2(this.dataView, itemIndex * 2, this.decimalType) : null;
+    }
+    getScaledValue(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? getInt16(this.dataView, itemIndex * 2) : null;
+    }
+    slice(offset, length) {
+        return new DuckDBDecimal2Vector(this.decimalType, new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 2, length * 2), this.validity.slice(offset), length);
+    }
+}
+exports.DuckDBDecimal2Vector = DuckDBDecimal2Vector;
+class DuckDBDecimal4Vector extends DuckDBVector {
+    decimalType;
+    dataView;
+    validity;
+    _itemCount;
+    constructor(decimalType, dataView, validity, itemCount) {
+        super();
+        this.decimalType = decimalType;
+        this.dataView = dataView;
+        this.validity = validity;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(decimalType, vector, itemCount) {
+        const data = vectorData(vector, itemCount * 4);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBDecimal4Vector(decimalType, dataView, validity, itemCount);
+    }
+    get type() {
+        return this.decimalType;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? getDecimal4(this.dataView, itemIndex * 4, this.decimalType) : null;
+    }
+    getScaledValue(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? getInt32(this.dataView, itemIndex * 4) : null;
+    }
+    slice(offset, length) {
+        return new DuckDBDecimal4Vector(this.decimalType, new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 4, length * 4), this.validity.slice(offset), length);
+    }
+}
+exports.DuckDBDecimal4Vector = DuckDBDecimal4Vector;
+class DuckDBDecimal8Vector extends DuckDBVector {
+    decimalType;
+    dataView;
+    validity;
+    _itemCount;
+    constructor(decimalType, dataView, validity, itemCount) {
+        super();
+        this.decimalType = decimalType;
+        this.dataView = dataView;
+        this.validity = validity;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(decimalType, vector, itemCount) {
+        const data = vectorData(vector, itemCount * 8);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBDecimal8Vector(decimalType, dataView, validity, itemCount);
+    }
+    get type() {
+        return this.decimalType;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? getDecimal8(this.dataView, itemIndex * 8, this.decimalType) : null;
+    }
+    getScaledValue(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? getInt64(this.dataView, itemIndex * 8) : null;
+    }
+    slice(offset, length) {
+        return new DuckDBDecimal8Vector(this.decimalType, new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 8, length * 8), this.validity.slice(offset), length);
+    }
+}
+exports.DuckDBDecimal8Vector = DuckDBDecimal8Vector;
+class DuckDBDecimal16Vector extends DuckDBVector {
+    decimalType;
+    dataView;
+    validity;
+    _itemCount;
+    constructor(decimalType, dataView, validity, itemCount) {
+        super();
+        this.decimalType = decimalType;
+        this.dataView = dataView;
+        this.validity = validity;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(decimalType, vector, itemCount) {
+        const data = vectorData(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBDecimal16Vector(decimalType, dataView, validity, itemCount);
+    }
+    get type() {
+        return this.decimalType;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? getDecimal16(this.dataView, itemIndex * 16, this.decimalType) : null;
+    }
+    getScaledValue(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? getInt128(this.dataView, itemIndex * 16) : null;
+    }
+    slice(offset, length) {
+        return new DuckDBDecimal16Vector(this.decimalType, new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset), length);
+    }
+}
+exports.DuckDBDecimal16Vector = DuckDBDecimal16Vector;
+class DuckDBTimestampSecondsVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimestampSecondsVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimestampSecondsType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBTimestampSecondsVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBTimestampSecondsVector = DuckDBTimestampSecondsVector;
+class DuckDBTimestampMillisecondsVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimestampMillisecondsVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimestampMillisecondsType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBTimestampMillisecondsVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBTimestampMillisecondsVector = DuckDBTimestampMillisecondsVector;
+class DuckDBTimestampNanosecondsVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimestampNanosecondsVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimestampNanosecondsType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBTimestampNanosecondsVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBTimestampNanosecondsVector = DuckDBTimestampNanosecondsVector;
+class DuckDBEnum1Vector extends DuckDBVector {
+    enumType;
+    items;
+    validity;
+    constructor(enumType, items, validity) {
+        super();
+        this.enumType = enumType;
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(enumType, vector, itemCount) {
+        const data = vectorData(vector, itemCount);
+        const items = new Uint8Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBEnum1Vector(enumType, items, validity);
+    }
+    get type() {
+        return this.enumType;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.enumType.values[this.items[itemIndex]] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBEnum1Vector(this.enumType, this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBEnum1Vector = DuckDBEnum1Vector;
+class DuckDBEnum2Vector extends DuckDBVector {
+    enumType;
+    items;
+    validity;
+    constructor(enumType, items, validity) {
+        super();
+        this.enumType = enumType;
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(enumType, vector, itemCount) {
+        const data = vectorData(vector, itemCount * 2);
+        const items = new Uint16Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBEnum2Vector(enumType, items, validity);
+    }
+    get type() {
+        return this.enumType;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.enumType.values[this.items[itemIndex]] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBEnum2Vector(this.enumType, this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBEnum2Vector = DuckDBEnum2Vector;
+class DuckDBEnum4Vector extends DuckDBVector {
+    enumType;
+    items;
+    validity;
+    constructor(enumType, items, validity) {
+        super();
+        this.enumType = enumType;
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(enumType, vector, itemCount) {
+        const data = vectorData(vector, itemCount * 4);
+        const items = new Uint32Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBEnum4Vector(enumType, items, validity);
+    }
+    get type() {
+        return this.enumType;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.enumType.values[this.items[itemIndex]] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBEnum4Vector(this.enumType, this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBEnum4Vector = DuckDBEnum4Vector;
+class DuckDBListVector extends DuckDBVector {
+    listType;
+    entryData;
+    validity;
+    childData;
+    _itemCount;
+    constructor(listType, entryData, validity, childData, itemCount) {
+        super();
+        this.listType = listType;
+        this.entryData = entryData;
+        this.validity = validity;
+        this.childData = childData;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(listType, vector, itemCount) {
+        const data = vectorData(vector, itemCount * BigUint64Array.BYTES_PER_ELEMENT * 2);
+        const entryData = new BigUint64Array(data.buffer, data.byteOffset, itemCount * 2);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        const child_vector = node_bindings_1.default.list_vector_get_child(vector);
+        const child_vector_size = node_bindings_1.default.list_vector_get_size(vector);
+        const childData = DuckDBVector.create(child_vector, child_vector_size, listType.valueType);
+        return new DuckDBListVector(listType, entryData, validity, childData, itemCount);
+    }
+    get type() {
+        return this.listType;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        const entryDataStartIndex = itemIndex * 2;
+        const offset = Number(this.entryData[entryDataStartIndex]);
+        const length = Number(this.entryData[entryDataStartIndex + 1]);
+        return this.childData.slice(offset, length);
+    }
+    slice(offset, length) {
+        const entryDataStartIndex = offset * 2;
+        return new DuckDBListVector(this.listType, this.entryData.slice(entryDataStartIndex, entryDataStartIndex + length * 2), this.validity.slice(offset), this.childData, length);
+    }
+}
+exports.DuckDBListVector = DuckDBListVector;
+class DuckDBStructVector extends DuckDBVector {
+    structType;
+    _itemCount;
+    entryVectors;
+    validity;
+    constructor(structType, itemCount, entryVectors, validity) {
+        super();
+        this.structType = structType;
+        this._itemCount = itemCount;
+        this.entryVectors = entryVectors;
+        this.validity = validity;
+    }
+    static fromRawVector(structType, vector, itemCount) {
+        const entryCount = structType.entries.length;
+        const entryVectors = [];
+        for (let i = 0; i < entryCount; i++) {
+            const entry = structType.entries[i];
+            const child_vector = node_bindings_1.default.struct_vector_get_child(vector, i);
+            entryVectors.push(DuckDBVector.create(child_vector, itemCount, entry.valueType));
+        }
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBStructVector(structType, itemCount, entryVectors, validity);
+    }
+    get type() {
+        return this.structType;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        const entries = [];
+        const entryCount = this.structType.entries.length;
+        for (let i = 0; i < entryCount; i++) {
+            const entry = this.structType.entries[i];
+            const entryVector = this.entryVectors[i];
+            entries.push({ name: entry.name, value: entryVector.getItem(itemIndex) });
+        }
+        return entries;
+    }
+    getItemValue(itemIndex, entryIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        const entryVector = this.entryVectors[entryIndex];
+        return entryVector.getItem(itemIndex);
+    }
+    slice(offset, length) {
+        return new DuckDBStructVector(this.structType, length, this.entryVectors.map(entryVector => entryVector.slice(offset, length)), this.validity.slice(offset));
+    }
+}
+exports.DuckDBStructVector = DuckDBStructVector;
+// MAP = LIST(STRUCT(key KEY_TYPE, value VALUE_TYPE))
+class DuckDBMapVector extends DuckDBVector {
+    mapType;
+    listVector;
+    constructor(mapType, listVector) {
+        super();
+        this.mapType = mapType;
+        this.listVector = listVector;
+    }
+    static fromRawVector(mapType, vector, itemCount) {
+        const listVectorType = new DuckDBType_1.DuckDBListType(new DuckDBType_1.DuckDBStructType([
+            { name: 'key', valueType: mapType.keyType },
+            { name: 'value', valueType: mapType.valueType }
+        ]));
+        return new DuckDBMapVector(mapType, DuckDBListVector.fromRawVector(listVectorType, vector, itemCount));
+    }
+    get type() {
+        return this.mapType;
+    }
+    get itemCount() {
+        return this.listVector.itemCount;
+    }
+    getItem(itemIndex) {
+        const itemVector = this.listVector.getItem(itemIndex);
+        if (!itemVector) {
+            return null;
+        }
+        if (!(itemVector instanceof DuckDBStructVector)) {
+            throw new Error('item in map list vector is not a struct');
+        }
+        const entries = [];
+        const itemEntryCount = itemVector.itemCount;
+        for (let i = 0; i < itemEntryCount; i++) {
+            const entry = itemVector.getItem(i);
+            if (!entry) {
+                throw new Error('null entry in map struct');
+            }
+            const keyEntry = entry[0];
+            const valueEntry = entry[1];
+            entries.push({ key: keyEntry.value, value: valueEntry.value });
+        }
+        return entries;
+    }
+    slice(offset, length) {
+        return new DuckDBMapVector(this.mapType, this.listVector.slice(offset, length));
+    }
+}
+exports.DuckDBMapVector = DuckDBMapVector;
+class DuckDBArrayVector extends DuckDBVector {
+    arrayType;
+    validity;
+    childData;
+    _itemCount;
+    constructor(arrayType, validity, childData, itemCount) {
+        super();
+        this.arrayType = arrayType;
+        this.validity = validity;
+        this.childData = childData;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(arrayType, vector, itemCount) {
+        const validity = 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.create(child_vector, itemCount * childItemsPerArray, arrayType.valueType);
+        return new DuckDBArrayVector(arrayType, validity, 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 this.childData.slice(itemIndex * this.arrayType.length, this.arrayType.length);
+    }
+    slice(offset, length) {
+        return new DuckDBArrayVector(this.arrayType, this.validity.slice(offset), this.childData.slice(offset * this.arrayType.length, length * this.arrayType.length), length);
+    }
+}
+exports.DuckDBArrayVector = DuckDBArrayVector;
+class DuckDBUUIDVector extends DuckDBVector {
+    dataView;
+    validity;
+    _itemCount;
+    constructor(dataView, validity, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBUUIDVector(dataView, validity, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBUUIDType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? getInt128(this.dataView, itemIndex * 16) : null;
+    }
+    slice(offset, length) {
+        return new DuckDBUUIDVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset), length);
+    }
+}
+exports.DuckDBUUIDVector = DuckDBUUIDVector;
+// UNION = STRUCT with first entry named "tag"
+class DuckDBUnionVector extends DuckDBVector {
+    unionType;
+    structVector;
+    constructor(unionType, structVector) {
+        super();
+        this.unionType = unionType;
+        this.structVector = structVector;
+    }
+    static fromRawVector(unionType, vector, itemCount) {
+        const structEntryTypes = [{ name: 'tag', valueType: DuckDBType_1.DuckDBUTinyIntType.instance }];
+        for (const alternative of unionType.alternatives) {
+            structEntryTypes.push({ name: alternative.tag, valueType: alternative.valueType });
+        }
+        const structVectorType = new DuckDBType_1.DuckDBStructType(structEntryTypes);
+        return new DuckDBUnionVector(unionType, 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 alternativeIndex = Number(tagValue);
+        const tag = this.unionType.alternatives[alternativeIndex].tag;
+        const entryIndex = alternativeIndex + 1;
+        const value = this.structVector.getItemValue(itemIndex, entryIndex);
+        return { tag, value };
+    }
+    slice(offset, length) {
+        return new DuckDBUnionVector(this.unionType, this.structVector.slice(offset, length));
+    }
+}
+exports.DuckDBUnionVector = DuckDBUnionVector;
+class DuckDBBitValue {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    static fromString(str) {
+        if (!/^[01]*$/.test(str)) {
+            throw new Error(`input string must only contain '0's and '1's`);
+        }
+        const byteCount = Math.ceil(str.length / 8) + 1;
+        const paddingBitCount = (8 - (str.length % 8)) % 8;
+        const data = new Uint8Array(byteCount);
+        let byteIndex = 0;
+        // first byte contains count of padding bits
+        data[byteIndex++] = paddingBitCount;
+        let byte = 0;
+        let bitIndex = 0;
+        // padding consists of 1s in MSB of second byte
+        while (bitIndex < paddingBitCount) {
+            byte <<= 1;
+            byte |= 1;
+            bitIndex++;
+        }
+        let charIndex = 0;
+        while (byteIndex < byteCount) {
+            while (bitIndex < 8) {
+                byte <<= 1;
+                if (str[charIndex++] === '1') {
+                    byte |= 1;
+                }
+                bitIndex++;
+            }
+            data[byteIndex++] = byte;
+            byte = 0;
+            bitIndex = 0;
+        }
+        return new DuckDBBitValue(data);
+    }
+    padding() {
+        return this.data[0];
+    }
+    length() {
+        return (this.data.length - 1) * 8 - this.padding();
+    }
+    getBool(index) {
+        const dataIndex = Math.floor(index / 8) + 1;
+        return (this.data[dataIndex] & (1 << (index % 8))) !== 0;
+    }
+    getBit(index) {
+        return this.getBool(index) ? 1 : 0;
+    }
+    toString() {
+        const chars = Array.from({ length: this.length() });
+        for (let i = 0; i < this.length(); i++) {
+            chars[i] = this.getBool(i) ? '1' : '0';
+        }
+        return chars.join('');
+    }
+}
+exports.DuckDBBitValue = DuckDBBitValue;
+class DuckDBBitVector extends DuckDBVector {
+    dataView;
+    validity;
+    _itemCount;
+    constructor(dataView, validity, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBBitVector(dataView, validity, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBBitType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        const bytes = getStringBytes(this.dataView, itemIndex * 16);
+        return bytes ? new DuckDBBitValue(bytes) : null;
+    }
+    slice(offset, length) {
+        return new DuckDBBitVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset), length);
+    }
+}
+exports.DuckDBBitVector = DuckDBBitVector;
+class DuckDBTimeTZValue {
+    /** Ranges from 0 to 86400000000 (= 24 * 60 * 60 * 1000 * 1000) */
+    microseconds;
+    /** In seconds, ranges from -57599 to 57599 (= 16 * 60 * 60 - 1) */
+    offset;
+    constructor(microseconds, offset) {
+        this.microseconds = microseconds;
+        this.offset = offset;
+    }
+    static TIME_BITS = 40;
+    static OFFSET_BITS = 24;
+    static MAX_OFFSET = 16 * 60 * 60 - 1; // ±15:59:59 = 57599 seconds
+    static fromBits(bits) {
+        const microseconds = Number(BigInt.asUintN(DuckDBTimeTZValue.TIME_BITS, bits >> BigInt(DuckDBTimeTZValue.OFFSET_BITS)));
+        const offset = DuckDBTimeTZValue.MAX_OFFSET - Number(BigInt.asUintN(DuckDBTimeTZValue.OFFSET_BITS, bits));
+        return new DuckDBTimeTZValue(microseconds, offset);
+    }
+}
+exports.DuckDBTimeTZValue = DuckDBTimeTZValue;
+class DuckDBTimeTZVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * BigUint64Array.BYTES_PER_ELEMENT);
+        const items = new BigUint64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimeTZVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimeTZType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? DuckDBTimeTZValue.fromBits(this.items[itemIndex]) : null;
+    }
+    slice(offset, length) {
+        return new DuckDBTimeTZVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBTimeTZVector = DuckDBTimeTZVector;
+class DuckDBTimestampTZVector extends DuckDBVector {
+    items;
+    validity;
+    constructor(items, validity) {
+        super();
+        this.items = items;
+        this.validity = validity;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * BigInt64Array.BYTES_PER_ELEMENT);
+        const items = new BigInt64Array(data.buffer, data.byteOffset, itemCount);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBTimestampTZVector(items, validity);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBTimestampTZType.instance;
+    }
+    get itemCount() {
+        return this.items.length;
+    }
+    getItem(itemIndex) {
+        return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+    }
+    slice(offset, length) {
+        return new DuckDBTimestampTZVector(this.items.slice(offset, offset + length), this.validity.slice(offset));
+    }
+}
+exports.DuckDBTimestampTZVector = DuckDBTimestampTZVector;
+class DuckDBVarIntVector extends DuckDBVector {
+    dataView;
+    validity;
+    _itemCount;
+    constructor(dataView, validity, itemCount) {
+        super();
+        this.dataView = dataView;
+        this.validity = validity;
+        this._itemCount = itemCount;
+    }
+    static fromRawVector(vector, itemCount) {
+        const data = vectorData(vector, itemCount * 16);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const validity = DuckDBValidity.fromVector(vector, itemCount);
+        return new DuckDBVarIntVector(dataView, validity, itemCount);
+    }
+    get type() {
+        return DuckDBType_1.DuckDBVarIntType.instance;
+    }
+    get itemCount() {
+        return this._itemCount;
+    }
+    getItem(itemIndex) {
+        if (!this.validity.itemValid(itemIndex)) {
+            return null;
+        }
+        const bytes = getStringBytes(this.dataView, itemIndex * 16);
+        return bytes ? getVarIntFromBytes(bytes) : null;
+    }
+    slice(offset, length) {
+        return new DuckDBVarIntVector(new DataView(this.dataView.buffer, this.dataView.byteOffset + offset * 16, length * 16), this.validity.slice(offset), length);
+    }
+}
+exports.DuckDBVarIntVector = DuckDBVarIntVector;