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

package/lib/vectors/createVector.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBLogicalType_1 = require("../DuckDBLogicalType");
+const DuckDBType_1 = require("../DuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+const DuckDBArrayVector_1 = require("./DuckDBArrayVector");
+const DuckDBBigIntVector_1 = require("./DuckDBBigIntVector");
+const DuckDBBigNumVector_1 = require("./DuckDBBigNumVector");
+const DuckDBBitVector_1 = require("./DuckDBBitVector");
+const DuckDBBlobVector_1 = require("./DuckDBBlobVector");
+const DuckDBBooleanVector_1 = require("./DuckDBBooleanVector");
+const DuckDBDateVector_1 = require("./DuckDBDateVector");
+const DuckDBDecimal128Vector_1 = require("./DuckDBDecimal128Vector");
+const DuckDBDecimal16Vector_1 = require("./DuckDBDecimal16Vector");
+const DuckDBDecimal32Vector_1 = require("./DuckDBDecimal32Vector");
+const DuckDBDecimal64Vector_1 = require("./DuckDBDecimal64Vector");
+const DuckDBDoubleVector_1 = require("./DuckDBDoubleVector");
+const DuckDBEnum16Vector_1 = require("./DuckDBEnum16Vector");
+const DuckDBEnum32Vector_1 = require("./DuckDBEnum32Vector");
+const DuckDBEnum8Vector_1 = require("./DuckDBEnum8Vector");
+const DuckDBFloatVector_1 = require("./DuckDBFloatVector");
+const DuckDBGeometryVector_1 = require("./DuckDBGeometryVector");
+const DuckDBHugeIntVector_1 = require("./DuckDBHugeIntVector");
+const DuckDBIntegerVector_1 = require("./DuckDBIntegerVector");
+const DuckDBIntervalVector_1 = require("./DuckDBIntervalVector");
+const DuckDBListVector_1 = require("./DuckDBListVector");
+const DuckDBMapVector_1 = require("./DuckDBMapVector");
+const DuckDBSmallIntVector_1 = require("./DuckDBSmallIntVector");
+const DuckDBSQLNullVector_1 = require("./DuckDBSQLNullVector");
+const DuckDBStructVector_1 = require("./DuckDBStructVector");
+const DuckDBTupleVector_1 = require("./DuckDBTupleVector");
+const DuckDBTimeNSVector_1 = require("./DuckDBTimeNSVector");
+const DuckDBTimeTZVector_1 = require("./DuckDBTimeTZVector");
+const DuckDBTimeVector_1 = require("./DuckDBTimeVector");
+const DuckDBTimestampMillisecondsVector_1 = require("./DuckDBTimestampMillisecondsVector");
+const DuckDBTimestampNanosecondsVector_1 = require("./DuckDBTimestampNanosecondsVector");
+const DuckDBTimestampSecondsVector_1 = require("./DuckDBTimestampSecondsVector");
+const DuckDBTimestampTZVector_1 = require("./DuckDBTimestampTZVector");
+const DuckDBTimestampTZNanosecondsVector_1 = require("./DuckDBTimestampTZNanosecondsVector");
+const DuckDBTimestampVector_1 = require("./DuckDBTimestampVector");
+const DuckDBTinyIntVector_1 = require("./DuckDBTinyIntVector");
+const DuckDBUBigIntVector_1 = require("./DuckDBUBigIntVector");
+const DuckDBUHugeIntVector_1 = require("./DuckDBUHugeIntVector");
+const DuckDBUIntegerVector_1 = require("./DuckDBUIntegerVector");
+const DuckDBUSmallIntVector_1 = require("./DuckDBUSmallIntVector");
+const DuckDBUTinyIntVector_1 = require("./DuckDBUTinyIntVector");
+const DuckDBUUIDVector_1 = require("./DuckDBUUIDVector");
+const DuckDBUnionVector_1 = require("./DuckDBUnionVector");
+const DuckDBVarCharVector_1 = require("./DuckDBVarCharVector");
+const DuckDBVariantVector_1 = require("./DuckDBVariantVector");
+const vectorRegistry_1 = require("./vectorRegistry");
+function createVector(vector, itemCount, knownType) {
+    const vectorType = knownType
+        ? knownType
+        : DuckDBLogicalType_1.DuckDBLogicalType.create(node_bindings_1.default.vector_get_column_type(vector)).asType();
+    switch (vectorType.typeId) {
+        case DuckDBTypeId_1.DuckDBTypeId.BOOLEAN:
+            return DuckDBBooleanVector_1.DuckDBBooleanVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.TINYINT:
+            return DuckDBTinyIntVector_1.DuckDBTinyIntVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.SMALLINT:
+            return DuckDBSmallIntVector_1.DuckDBSmallIntVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.INTEGER:
+            return DuckDBIntegerVector_1.DuckDBIntegerVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.BIGINT:
+            return DuckDBBigIntVector_1.DuckDBBigIntVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.UTINYINT:
+            return DuckDBUTinyIntVector_1.DuckDBUTinyIntVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.USMALLINT:
+            return DuckDBUSmallIntVector_1.DuckDBUSmallIntVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.UINTEGER:
+            return DuckDBUIntegerVector_1.DuckDBUIntegerVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.UBIGINT:
+            return DuckDBUBigIntVector_1.DuckDBUBigIntVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.FLOAT:
+            return DuckDBFloatVector_1.DuckDBFloatVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.DOUBLE:
+            return DuckDBDoubleVector_1.DuckDBDoubleVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP:
+            return DuckDBTimestampVector_1.DuckDBTimestampVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.DATE:
+            return DuckDBDateVector_1.DuckDBDateVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.TIME:
+            return DuckDBTimeVector_1.DuckDBTimeVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.INTERVAL:
+            return DuckDBIntervalVector_1.DuckDBIntervalVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.HUGEINT:
+            return DuckDBHugeIntVector_1.DuckDBHugeIntVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.UHUGEINT:
+            return DuckDBUHugeIntVector_1.DuckDBUHugeIntVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.VARCHAR:
+            return DuckDBVarCharVector_1.DuckDBVarCharVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.BLOB:
+            return DuckDBBlobVector_1.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 DuckDBDecimal16Vector_1.DuckDBDecimal16Vector.fromRawVector(vectorType, vector, itemCount);
+                }
+                else if (width <= 9) {
+                    return DuckDBDecimal32Vector_1.DuckDBDecimal32Vector.fromRawVector(vectorType, vector, itemCount);
+                }
+                else if (width <= 18) {
+                    return DuckDBDecimal64Vector_1.DuckDBDecimal64Vector.fromRawVector(vectorType, vector, itemCount);
+                }
+                else if (width <= 38) {
+                    return DuckDBDecimal128Vector_1.DuckDBDecimal128Vector.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_1.DuckDBTimestampSecondsVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_MS:
+            return DuckDBTimestampMillisecondsVector_1.DuckDBTimestampMillisecondsVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_NS:
+            return DuckDBTimestampNanosecondsVector_1.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 DuckDBEnum8Vector_1.DuckDBEnum8Vector.fromRawVector(vectorType, vector, itemCount);
+                    case DuckDBTypeId_1.DuckDBTypeId.USMALLINT:
+                        return DuckDBEnum16Vector_1.DuckDBEnum16Vector.fromRawVector(vectorType, vector, itemCount);
+                    case DuckDBTypeId_1.DuckDBTypeId.UINTEGER:
+                        return DuckDBEnum32Vector_1.DuckDBEnum32Vector.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_1.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) {
+                if (vectorType.isTuple) {
+                    return DuckDBTupleVector_1.DuckDBTupleVector.fromRawVector(vectorType, vector, itemCount);
+                }
+                return DuckDBStructVector_1.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_1.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_1.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_1.DuckDBUUIDVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.UNION:
+            if (vectorType instanceof DuckDBType_1.DuckDBUnionType) {
+                return DuckDBUnionVector_1.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_1.DuckDBBitVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.TIME_TZ:
+            return DuckDBTimeTZVector_1.DuckDBTimeTZVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_TZ:
+            return DuckDBTimestampTZVector_1.DuckDBTimestampTZVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.ANY:
+            throw new Error(`Invalid vector type: ANY`);
+        case DuckDBTypeId_1.DuckDBTypeId.BIGNUM:
+            return DuckDBBigNumVector_1.DuckDBBigNumVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.SQLNULL:
+            return DuckDBSQLNullVector_1.DuckDBSQLNullVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.STRING_LITERAL:
+            throw new Error(`Invalid vector type: STRING_LITERAL`);
+        case DuckDBTypeId_1.DuckDBTypeId.INTEGER_LITERAL:
+            throw new Error(`Invalid vector type: INTEGER_LITERAL`);
+        case DuckDBTypeId_1.DuckDBTypeId.TIME_NS:
+            return DuckDBTimeNSVector_1.DuckDBTimeNSVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.GEOMETRY:
+            return DuckDBGeometryVector_1.DuckDBGeometryVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.VARIANT:
+            return DuckDBVariantVector_1.DuckDBVariantVector.fromRawVector(vector, itemCount);
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_TZ_NS:
+            return DuckDBTimestampTZNanosecondsVector_1.DuckDBTimestampTZNanosecondsVector.fromRawVector(vector, itemCount);
+        default:
+            throw new Error(`Invalid type id: ${vectorType.typeId}`);
+    }
+}
+vectorRegistry_1.vectorRegistry.create = createVector;

package/lib/vectors/dataAccessors.d.ts

@@ -0,0 +1,45 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBDecimalType } from '../DuckDBType';
+import { DuckDBDecimalValue } from '../values';
+export declare const littleEndian: boolean;
+export declare function getUInt8(dataView: DataView, offset: number): number;
+export declare function getInt16(dataView: DataView, offset: number): number;
+export declare function getUInt16(dataView: DataView, offset: number): number;
+export declare function getInt32(dataView: DataView, offset: number): number;
+export declare function getUInt32(dataView: DataView, offset: number): number;
+export declare function getInt64(dataView: DataView, offset: number): bigint;
+export declare function getUInt64(dataView: DataView, offset: number): bigint;
+export declare function getInt128(dataView: DataView, offset: number): bigint;
+export declare function getUInt128(dataView: DataView, offset: number): bigint;
+export declare function getStringBytes(dataView: DataView, offset: number): Uint8Array;
+export declare const textDecoder: TextDecoder;
+export declare function getString(dataView: DataView, offset: number): string;
+export declare function getBuffer(dataView: DataView, offset: number): Buffer;
+export declare function getBigNumFromBytes(bytes: Uint8Array): bigint;
+export declare function getBytesFromBigNum(bignum: bigint): Uint8Array;
+export declare function getBoolean1(dataView: DataView, offset: number): boolean;
+export declare function getBoolean2(dataView: DataView, offset: number): boolean;
+export declare function getBoolean4(dataView: DataView, offset: number): boolean;
+export declare function getBoolean8(dataView: DataView, offset: number): boolean;
+export declare function makeGetBoolean(): (dataView: DataView, offset: number) => boolean;
+export declare const getBoolean: (dataView: DataView, offset: number) => boolean;
+export declare function setUInt8(dataView: DataView, offset: number, value: number): void;
+export declare function setInt16(dataView: DataView, offset: number, value: number): void;
+export declare function setUInt16(dataView: DataView, offset: number, value: number): void;
+export declare function setInt32(dataView: DataView, offset: number, value: number): void;
+export declare function setUInt32(dataView: DataView, offset: number, value: number): void;
+export declare function setInt64(dataView: DataView, offset: number, value: bigint): void;
+export declare function setUInt64(dataView: DataView, offset: number, value: bigint): void;
+export declare function setInt128(dataView: DataView, offset: number, value: bigint): void;
+export declare function setUInt128(dataView: DataView, offset: number, value: bigint): void;
+export declare function setBoolean1(dataView: DataView, offset: number, value: boolean): void;
+export declare function setBoolean2(dataView: DataView, offset: number, value: boolean): void;
+export declare function setBoolean4(dataView: DataView, offset: number, value: boolean): void;
+export declare function setBoolean8(dataView: DataView, offset: number, value: boolean): void;
+export declare function makeSetBoolean(): (dataView: DataView, offset: number, value: boolean) => void;
+export declare const setBoolean: (dataView: DataView, offset: number, value: boolean) => void;
+export declare function getDecimal16(dataView: DataView, offset: number, type: DuckDBDecimalType): DuckDBDecimalValue;
+export declare function getDecimal32(dataView: DataView, offset: number, type: DuckDBDecimalType): DuckDBDecimalValue;
+export declare function getDecimal64(dataView: DataView, offset: number, type: DuckDBDecimalType): DuckDBDecimalValue;
+export declare function getDecimal128(dataView: DataView, offset: number, type: DuckDBDecimalType): DuckDBDecimalValue;
+export declare function vectorData(vector: duckdb.Vector, byteCount: number): Uint8Array;

package/lib/vectors/dataAccessors.js

@@ -0,0 +1,344 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setBoolean = exports.getBoolean = exports.textDecoder = exports.littleEndian = void 0;
+exports.getUInt8 = getUInt8;
+exports.getInt16 = getInt16;
+exports.getUInt16 = getUInt16;
+exports.getInt32 = getInt32;
+exports.getUInt32 = getUInt32;
+exports.getInt64 = getInt64;
+exports.getUInt64 = getUInt64;
+exports.getInt128 = getInt128;
+exports.getUInt128 = getUInt128;
+exports.getStringBytes = getStringBytes;
+exports.getString = getString;
+exports.getBuffer = getBuffer;
+exports.getBigNumFromBytes = getBigNumFromBytes;
+exports.getBytesFromBigNum = getBytesFromBigNum;
+exports.getBoolean1 = getBoolean1;
+exports.getBoolean2 = getBoolean2;
+exports.getBoolean4 = getBoolean4;
+exports.getBoolean8 = getBoolean8;
+exports.makeGetBoolean = makeGetBoolean;
+exports.setUInt8 = setUInt8;
+exports.setInt16 = setInt16;
+exports.setUInt16 = setUInt16;
+exports.setInt32 = setInt32;
+exports.setUInt32 = setUInt32;
+exports.setInt64 = setInt64;
+exports.setUInt64 = setUInt64;
+exports.setInt128 = setInt128;
+exports.setUInt128 = setUInt128;
+exports.setBoolean1 = setBoolean1;
+exports.setBoolean2 = setBoolean2;
+exports.setBoolean4 = setBoolean4;
+exports.setBoolean8 = setBoolean8;
+exports.makeSetBoolean = makeSetBoolean;
+exports.getDecimal16 = getDecimal16;
+exports.getDecimal32 = getDecimal32;
+exports.getDecimal64 = getDecimal64;
+exports.getDecimal128 = getDecimal128;
+exports.vectorData = vectorData;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const os_1 = __importDefault(require("os"));
+const values_1 = require("../values");
+exports.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, exports.littleEndian);
+}
+function getUInt16(dataView, offset) {
+    return dataView.getUint16(offset, exports.littleEndian);
+}
+function getInt32(dataView, offset) {
+    return dataView.getInt32(offset, exports.littleEndian);
+}
+function getUInt32(dataView, offset) {
+    return dataView.getUint32(offset, exports.littleEndian);
+}
+function getInt64(dataView, offset) {
+    return dataView.getBigInt64(offset, exports.littleEndian);
+}
+function getUInt64(dataView, offset) {
+    return dataView.getBigUint64(offset, exports.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);
+    }
+}
+exports.textDecoder = new TextDecoder();
+function getString(dataView, offset) {
+    const stringBytes = getStringBytes(dataView, offset);
+    return exports.textDecoder.decode(stringBytes);
+}
+function getBuffer(dataView, offset) {
+    const stringBytes = getStringBytes(dataView, offset);
+    return Buffer.from(stringBytes);
+}
+function getBigNumFromBytes(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 is big endian
+    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 getBytesFromBigNum(bignum) {
+    const numberBytes = []; // little endian
+    const negative = bignum < 0;
+    if (bignum === 0n) {
+        numberBytes.push(0);
+    }
+    else {
+        let vi = bignum < 0 ? -bignum : bignum;
+        while (vi !== 0n) {
+            numberBytes.push(Number(BigInt.asUintN(8, vi)));
+            vi >>= 8n;
+        }
+    }
+    const bigNumBytes = new Uint8Array(3 + numberBytes.length); // big endian
+    let header = 0x800000 | numberBytes.length;
+    if (negative) {
+        header = ~header;
+    }
+    bigNumBytes[0] = 0xff & (header >> 16);
+    bigNumBytes[1] = 0xff & (header >> 8);
+    bigNumBytes[2] = 0xff & header;
+    for (let i = 0; i < numberBytes.length; i++) {
+        const byte = numberBytes[numberBytes.length - 1 - i];
+        bigNumBytes[3 + i] = negative ? ~byte : byte;
+    }
+    return bigNumBytes;
+}
+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}`);
+    }
+}
+exports.getBoolean = makeGetBoolean();
+// Range checks for fixed-width integers
+// Writing a number to a DataView applies the JS ToInt32 and ToUint32 operations,
+// which wrap out-of-range values modulo the type's width and truncate fractional
+// ones; writing a bigint wraps in the same way. Doing that for data values would
+// silently store something other than what the caller supplied, so the setters
+// below check first. See duckdb/duckdb-node-neo#469.
+//
+// The vectors backed by a typed array rather than a DataView repeat these checks
+// inline instead of calling them: they sit in the inner loop of every bulk write,
+// and calling across a module boundary there costs about 20% of write throughput.
+// Keep the two in sync; api/test/integer-ranges.test.ts checks every bound.
+function checkUInt8(value) {
+    if (!Number.isInteger(value)) {
+        throw new Error(`number is not an integer`);
+    }
+    if (value < 0 || value > 255) {
+        throw new Error(`number out of uint8 range`);
+    }
+    return value;
+}
+function checkInt16(value) {
+    if (!Number.isInteger(value)) {
+        throw new Error(`number is not an integer`);
+    }
+    if (value < -32768 || value > 32767) {
+        throw new Error(`number out of int16 range`);
+    }
+    return value;
+}
+function checkUInt16(value) {
+    if (!Number.isInteger(value)) {
+        throw new Error(`number is not an integer`);
+    }
+    if (value < 0 || value > 65535) {
+        throw new Error(`number out of uint16 range`);
+    }
+    return value;
+}
+function checkInt32(value) {
+    if (!Number.isInteger(value)) {
+        throw new Error(`number is not an integer`);
+    }
+    if (value < -2147483648 || value > 2147483647) {
+        throw new Error(`number out of int32 range`);
+    }
+    return value;
+}
+function checkUInt32(value) {
+    if (!Number.isInteger(value)) {
+        throw new Error(`number is not an integer`);
+    }
+    if (value < 0 || value > 4294967295) {
+        throw new Error(`number out of uint32 range`);
+    }
+    return value;
+}
+function checkInt64(value) {
+    if (BigInt.asIntN(64, value) !== value) {
+        throw new Error(`bigint out of int64 range`);
+    }
+    return value;
+}
+function checkUInt64(value) {
+    if (BigInt.asUintN(64, value) !== value) {
+        throw new Error(`bigint out of uint64 range`);
+    }
+    return value;
+}
+function checkInt128(value) {
+    if (BigInt.asIntN(128, value) !== value) {
+        throw new Error(`bigint out of int128 range`);
+    }
+    return value;
+}
+function checkUInt128(value) {
+    if (BigInt.asUintN(128, value) !== value) {
+        throw new Error(`bigint out of uint128 range`);
+    }
+    return value;
+}
+// function setInt8(dataView: DataView, offset: number, value: number) {
+//   dataView.setInt8(offset, value);
+// }
+function setUInt8(dataView, offset, value) {
+    dataView.setUint8(offset, checkUInt8(value));
+}
+function setInt16(dataView, offset, value) {
+    dataView.setInt16(offset, checkInt16(value), exports.littleEndian);
+}
+function setUInt16(dataView, offset, value) {
+    dataView.setUint16(offset, checkUInt16(value), exports.littleEndian);
+}
+function setInt32(dataView, offset, value) {
+    dataView.setInt32(offset, checkInt32(value), exports.littleEndian);
+}
+function setUInt32(dataView, offset, value) {
+    dataView.setUint32(offset, checkUInt32(value), exports.littleEndian);
+}
+function setInt64(dataView, offset, value) {
+    dataView.setBigInt64(offset, checkInt64(value), exports.littleEndian);
+}
+function setUInt64(dataView, offset, value) {
+    dataView.setBigUint64(offset, checkUInt64(value), exports.littleEndian);
+}
+function setInt128(dataView, offset, value) {
+    checkInt128(value);
+    const lower = BigInt.asUintN(64, value);
+    const upper = BigInt.asIntN(64, value >> BigInt(64));
+    dataView.setBigUint64(offset, lower, exports.littleEndian);
+    dataView.setBigInt64(offset + 8, upper, exports.littleEndian);
+}
+function setUInt128(dataView, offset, value) {
+    checkUInt128(value);
+    const lower = BigInt.asUintN(64, value);
+    const upper = BigInt.asUintN(64, value >> BigInt(64));
+    dataView.setBigUint64(offset, lower, exports.littleEndian);
+    dataView.setBigUint64(offset + 8, upper, exports.littleEndian);
+}
+function setBoolean1(dataView, offset, value) {
+    setUInt8(dataView, offset, value ? 1 : 0);
+}
+function setBoolean2(dataView, offset, value) {
+    setUInt16(dataView, offset, value ? 1 : 0);
+}
+function setBoolean4(dataView, offset, value) {
+    setUInt32(dataView, offset, value ? 1 : 0);
+}
+function setBoolean8(dataView, offset, value) {
+    setUInt64(dataView, offset, value ? BigInt(1) : BigInt(0));
+}
+function makeSetBoolean() {
+    switch (node_bindings_1.default.sizeof_bool) {
+        case 1:
+            return setBoolean1;
+        case 2:
+            return setBoolean2;
+        case 4:
+            return setBoolean4;
+        case 8:
+            return setBoolean8;
+        default:
+            throw new Error(`Unsupported boolean size: ${node_bindings_1.default.sizeof_bool}`);
+    }
+}
+exports.setBoolean = makeSetBoolean();
+function getDecimal16(dataView, offset, type) {
+    const value = getInt16(dataView, offset);
+    return new values_1.DuckDBDecimalValue(BigInt(value), type.width, type.scale);
+}
+function getDecimal32(dataView, offset, type) {
+    const value = getInt32(dataView, offset);
+    return new values_1.DuckDBDecimalValue(BigInt(value), type.width, type.scale);
+}
+function getDecimal64(dataView, offset, type) {
+    const value = getInt64(dataView, offset);
+    return new values_1.DuckDBDecimalValue(value, type.width, type.scale);
+}
+function getDecimal128(dataView, offset, type) {
+    const value = getInt128(dataView, offset);
+    return new values_1.DuckDBDecimalValue(value, type.width, type.scale);
+}
+function vectorData(vector, byteCount) {
+    return node_bindings_1.default.vector_get_data(vector, byteCount);
+}

package/lib/vectors/index.d.ts

@@ -0,0 +1,47 @@
+export * from './DuckDBArrayVector';
+export * from './DuckDBBigIntVector';
+export * from './DuckDBBigNumVector';
+export * from './DuckDBBitVector';
+export * from './DuckDBBlobVector';
+export * from './DuckDBBooleanVector';
+export * from './DuckDBDateVector';
+export * from './DuckDBDecimal128Vector';
+export * from './DuckDBDecimal16Vector';
+export * from './DuckDBDecimal32Vector';
+export * from './DuckDBDecimal64Vector';
+export * from './DuckDBDoubleVector';
+export * from './DuckDBEnum16Vector';
+export * from './DuckDBEnum32Vector';
+export * from './DuckDBEnum8Vector';
+export * from './DuckDBFloatVector';
+export * from './DuckDBGeometryVector';
+export * from './DuckDBHugeIntVector';
+export * from './DuckDBIntegerVector';
+export * from './DuckDBIntervalVector';
+export * from './DuckDBListVector';
+export * from './DuckDBMapVector';
+export * from './DuckDBSmallIntVector';
+export * from './DuckDBSQLNullVector';
+export * from './DuckDBStructVector';
+export * from './DuckDBTimeNSVector';
+export * from './DuckDBTimeTZVector';
+export * from './DuckDBTimeVector';
+export * from './DuckDBTimestampMillisecondsVector';
+export * from './DuckDBTimestampNanosecondsVector';
+export * from './DuckDBTimestampSecondsVector';
+export * from './DuckDBTimestampTZVector';
+export * from './DuckDBTimestampTZNanosecondsVector';
+export * from './DuckDBTimestampVector';
+export * from './DuckDBTinyIntVector';
+export * from './DuckDBTupleVector';
+export * from './DuckDBUBigIntVector';
+export * from './DuckDBUHugeIntVector';
+export * from './DuckDBUIntegerVector';
+export * from './DuckDBUSmallIntVector';
+export * from './DuckDBUTinyIntVector';
+export * from './DuckDBUUIDVector';
+export * from './DuckDBUnionVector';
+export * from './DuckDBVarCharVector';
+export * from './DuckDBVariantVector';
+export * from './DuckDBVector';
+import './createVector';