@avidian/duckdb-bun 0.0.0-stage → 1.0.0

package/vendor/node-api/src/vectors/createVector.ts

@@ -0,0 +1,269 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import {
+  DuckDBArrayType,
+  DuckDBDecimalType,
+  DuckDBEnumType,
+  DuckDBListType,
+  DuckDBMapType,
+  DuckDBStructType,
+  DuckDBType,
+  DuckDBUnionType,
+} from '../DuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBArrayVector } from './DuckDBArrayVector';
+import { DuckDBBigIntVector } from './DuckDBBigIntVector';
+import { DuckDBBigNumVector } from './DuckDBBigNumVector';
+import { DuckDBBitVector } from './DuckDBBitVector';
+import { DuckDBBlobVector } from './DuckDBBlobVector';
+import { DuckDBBooleanVector } from './DuckDBBooleanVector';
+import { DuckDBDateVector } from './DuckDBDateVector';
+import { DuckDBDecimal128Vector } from './DuckDBDecimal128Vector';
+import { DuckDBDecimal16Vector } from './DuckDBDecimal16Vector';
+import { DuckDBDecimal32Vector } from './DuckDBDecimal32Vector';
+import { DuckDBDecimal64Vector } from './DuckDBDecimal64Vector';
+import { DuckDBDoubleVector } from './DuckDBDoubleVector';
+import { DuckDBEnum16Vector } from './DuckDBEnum16Vector';
+import { DuckDBEnum32Vector } from './DuckDBEnum32Vector';
+import { DuckDBEnum8Vector } from './DuckDBEnum8Vector';
+import { DuckDBFloatVector } from './DuckDBFloatVector';
+import { DuckDBGeometryVector } from './DuckDBGeometryVector';
+import { DuckDBHugeIntVector } from './DuckDBHugeIntVector';
+import { DuckDBIntegerVector } from './DuckDBIntegerVector';
+import { DuckDBIntervalVector } from './DuckDBIntervalVector';
+import { DuckDBListVector } from './DuckDBListVector';
+import { DuckDBMapVector } from './DuckDBMapVector';
+import { DuckDBSmallIntVector } from './DuckDBSmallIntVector';
+import { DuckDBSQLNullVector } from './DuckDBSQLNullVector';
+import { DuckDBStructVector } from './DuckDBStructVector';
+import { DuckDBTupleVector } from './DuckDBTupleVector';
+import { DuckDBTimeNSVector } from './DuckDBTimeNSVector';
+import { DuckDBTimeTZVector } from './DuckDBTimeTZVector';
+import { DuckDBTimeVector } from './DuckDBTimeVector';
+import { DuckDBTimestampMillisecondsVector } from './DuckDBTimestampMillisecondsVector';
+import { DuckDBTimestampNanosecondsVector } from './DuckDBTimestampNanosecondsVector';
+import { DuckDBTimestampSecondsVector } from './DuckDBTimestampSecondsVector';
+import { DuckDBTimestampTZVector } from './DuckDBTimestampTZVector';
+import { DuckDBTimestampTZNanosecondsVector } from './DuckDBTimestampTZNanosecondsVector';
+import { DuckDBTimestampVector } from './DuckDBTimestampVector';
+import { DuckDBTinyIntVector } from './DuckDBTinyIntVector';
+import { DuckDBUBigIntVector } from './DuckDBUBigIntVector';
+import { DuckDBUHugeIntVector } from './DuckDBUHugeIntVector';
+import { DuckDBUIntegerVector } from './DuckDBUIntegerVector';
+import { DuckDBUSmallIntVector } from './DuckDBUSmallIntVector';
+import { DuckDBUTinyIntVector } from './DuckDBUTinyIntVector';
+import { DuckDBUUIDVector } from './DuckDBUUIDVector';
+import { DuckDBUnionVector } from './DuckDBUnionVector';
+import { DuckDBVarCharVector } from './DuckDBVarCharVector';
+import { DuckDBVariantVector } from './DuckDBVariantVector';
+import { vectorRegistry } from './vectorRegistry';
+
+function createVector(
+  vector: duckdb.Vector,
+  itemCount: number,
+  knownType?: DuckDBType
+): DuckDBVector {
+    const vectorType = knownType
+      ? knownType
+      : DuckDBLogicalType.create(
+          duckdb.vector_get_column_type(vector)
+        ).asType();
+    switch (vectorType.typeId) {
+      case DuckDBTypeId.BOOLEAN:
+        return DuckDBBooleanVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.TINYINT:
+        return DuckDBTinyIntVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.SMALLINT:
+        return DuckDBSmallIntVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.INTEGER:
+        return DuckDBIntegerVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.BIGINT:
+        return DuckDBBigIntVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.UTINYINT:
+        return DuckDBUTinyIntVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.USMALLINT:
+        return DuckDBUSmallIntVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.UINTEGER:
+        return DuckDBUIntegerVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.UBIGINT:
+        return DuckDBUBigIntVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.FLOAT:
+        return DuckDBFloatVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.DOUBLE:
+        return DuckDBDoubleVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.TIMESTAMP:
+        return DuckDBTimestampVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.DATE:
+        return DuckDBDateVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.TIME:
+        return DuckDBTimeVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.INTERVAL:
+        return DuckDBIntervalVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.HUGEINT:
+        return DuckDBHugeIntVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.UHUGEINT:
+        return DuckDBUHugeIntVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.VARCHAR:
+        return DuckDBVarCharVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.BLOB:
+        return DuckDBBlobVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.DECIMAL:
+        if (vectorType instanceof DuckDBDecimalType) {
+          const { width } = vectorType;
+          if (width <= 0) {
+            throw new Error(`DECIMAL width not positive: ${width}`);
+          } else if (width <= 4) {
+            return DuckDBDecimal16Vector.fromRawVector(
+              vectorType,
+              vector,
+              itemCount
+            );
+          } else if (width <= 9) {
+            return DuckDBDecimal32Vector.fromRawVector(
+              vectorType,
+              vector,
+              itemCount
+            );
+          } else if (width <= 18) {
+            return DuckDBDecimal64Vector.fromRawVector(
+              vectorType,
+              vector,
+              itemCount
+            );
+          } else if (width <= 38) {
+            return 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.TIMESTAMP_S:
+        return DuckDBTimestampSecondsVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.TIMESTAMP_MS:
+        return DuckDBTimestampMillisecondsVector.fromRawVector(
+          vector,
+          itemCount
+        );
+      case DuckDBTypeId.TIMESTAMP_NS:
+        return DuckDBTimestampNanosecondsVector.fromRawVector(
+          vector,
+          itemCount
+        );
+      case DuckDBTypeId.ENUM:
+        if (vectorType instanceof DuckDBEnumType) {
+          const { internalTypeId } = vectorType;
+          switch (internalTypeId) {
+            case DuckDBTypeId.UTINYINT:
+              return DuckDBEnum8Vector.fromRawVector(
+                vectorType,
+                vector,
+                itemCount
+              );
+            case DuckDBTypeId.USMALLINT:
+              return DuckDBEnum16Vector.fromRawVector(
+                vectorType,
+                vector,
+                itemCount
+              );
+            case DuckDBTypeId.UINTEGER:
+              return 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.LIST:
+        if (vectorType instanceof DuckDBListType) {
+          return DuckDBListVector.fromRawVector(vectorType, vector, itemCount);
+        }
+        throw new Error(
+          'DuckDBType has LIST type id but is not an instance of DuckDBListType'
+        );
+      case DuckDBTypeId.STRUCT:
+        if (vectorType instanceof DuckDBStructType) {
+          if (vectorType.isTuple) {
+            return DuckDBTupleVector.fromRawVector(
+              vectorType,
+              vector,
+              itemCount
+            );
+          }
+          return DuckDBStructVector.fromRawVector(
+            vectorType,
+            vector,
+            itemCount
+          );
+        }
+        throw new Error(
+          'DuckDBType has STRUCT type id but is not an instance of DuckDBStructType'
+        );
+      case DuckDBTypeId.MAP:
+        if (vectorType instanceof DuckDBMapType) {
+          return DuckDBMapVector.fromRawVector(vectorType, vector, itemCount);
+        }
+        throw new Error(
+          'DuckDBType has MAP type id but is not an instance of DuckDBMapType'
+        );
+      case DuckDBTypeId.ARRAY:
+        if (vectorType instanceof DuckDBArrayType) {
+          return DuckDBArrayVector.fromRawVector(vectorType, vector, itemCount);
+        }
+        throw new Error(
+          'DuckDBType has ARRAY type id but is not an instance of DuckDBArrayType'
+        );
+      case DuckDBTypeId.UUID:
+        return DuckDBUUIDVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.UNION:
+        if (vectorType instanceof DuckDBUnionType) {
+          return DuckDBUnionVector.fromRawVector(vectorType, vector, itemCount);
+        }
+        throw new Error(
+          'DuckDBType has UNION type id but is not an instance of DuckDBUnionType'
+        );
+      case DuckDBTypeId.BIT:
+        return DuckDBBitVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.TIME_TZ:
+        return DuckDBTimeTZVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.TIMESTAMP_TZ:
+        return DuckDBTimestampTZVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.ANY:
+        throw new Error(`Invalid vector type: ANY`);
+      case DuckDBTypeId.BIGNUM:
+        return DuckDBBigNumVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.SQLNULL:
+        return DuckDBSQLNullVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.STRING_LITERAL:
+        throw new Error(`Invalid vector type: STRING_LITERAL`);
+      case DuckDBTypeId.INTEGER_LITERAL:
+        throw new Error(`Invalid vector type: INTEGER_LITERAL`);
+      case DuckDBTypeId.TIME_NS:
+        return DuckDBTimeNSVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.GEOMETRY:
+        return DuckDBGeometryVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.VARIANT:
+        return DuckDBVariantVector.fromRawVector(vector, itemCount);
+      case DuckDBTypeId.TIMESTAMP_TZ_NS:
+        return DuckDBTimestampTZNanosecondsVector.fromRawVector(vector, itemCount);
+      default:
+        throw new Error(
+          `Invalid type id: ${(vectorType as DuckDBType).typeId}`
+        );
+    }
+}
+
+vectorRegistry.create = createVector;

package/vendor/node-api/src/vectors/dataAccessors.ts

@@ -0,0 +1,387 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import os from 'os';
+import { DuckDBDecimalType } from '../DuckDBType';
+import { DuckDBDecimalValue } from '../values';
+
+export const littleEndian = os.endianness() === 'LE';
+
+// function getInt8(dataView: DataView, offset: number): number {
+//   return dataView.getInt8(offset);
+// }
+
+export function getUInt8(dataView: DataView, offset: number): number {
+  return dataView.getUint8(offset);
+}
+
+export function getInt16(dataView: DataView, offset: number): number {
+  return dataView.getInt16(offset, littleEndian);
+}
+
+export function getUInt16(dataView: DataView, offset: number): number {
+  return dataView.getUint16(offset, littleEndian);
+}
+
+export function getInt32(dataView: DataView, offset: number): number {
+  return dataView.getInt32(offset, littleEndian);
+}
+
+export function getUInt32(dataView: DataView, offset: number): number {
+  return dataView.getUint32(offset, littleEndian);
+}
+
+export function getInt64(dataView: DataView, offset: number): bigint {
+  return dataView.getBigInt64(offset, littleEndian);
+}
+
+export function getUInt64(dataView: DataView, offset: number): bigint {
+  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);
+// }
+
+export function getInt128(dataView: DataView, offset: number): bigint {
+  const lower = getUInt64(dataView, offset);
+  const upper = getInt64(dataView, offset + 8);
+  return (upper << BigInt(64)) + lower;
+}
+
+export function getUInt128(dataView: DataView, offset: number): bigint {
+  const lower = getUInt64(dataView, offset);
+  const upper = getUInt64(dataView, offset + 8);
+  return (BigInt.asUintN(64, upper) << BigInt(64)) | BigInt.asUintN(64, lower);
+}
+
+export function getStringBytes(dataView: DataView, offset: number): Uint8Array {
+  const lengthInBytes = dataView.getUint32(offset, true);
+  if (lengthInBytes <= 12) {
+    return new Uint8Array(
+      dataView.buffer,
+      dataView.byteOffset + offset + 4,
+      lengthInBytes
+    );
+  } else {
+    return duckdb.get_data_from_pointer(
+      dataView.buffer as ArrayBuffer,
+      dataView.byteOffset + offset + 8,
+      lengthInBytes
+    );
+  }
+}
+
+export const textDecoder = new TextDecoder();
+
+export function getString(dataView: DataView, offset: number): string {
+  const stringBytes = getStringBytes(dataView, offset);
+  return textDecoder.decode(stringBytes);
+}
+
+export function getBuffer(dataView: DataView, offset: number): Buffer {
+  const stringBytes = getStringBytes(dataView, offset);
+  return Buffer.from(stringBytes);
+}
+
+export function getBigNumFromBytes(bytes: Uint8Array): bigint {
+  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;
+}
+
+export function getBytesFromBigNum(bignum: bigint): Uint8Array {
+  const numberBytes: number[] = []; // 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;
+}
+
+export function getBoolean1(dataView: DataView, offset: number): boolean {
+  return getUInt8(dataView, offset) !== 0;
+}
+
+export function getBoolean2(dataView: DataView, offset: number): boolean {
+  return getUInt16(dataView, offset) !== 0;
+}
+
+export function getBoolean4(dataView: DataView, offset: number): boolean {
+  return getUInt32(dataView, offset) !== 0;
+}
+
+export function getBoolean8(dataView: DataView, offset: number): boolean {
+  return getUInt64(dataView, offset) !== BigInt(0);
+}
+
+export function makeGetBoolean(): (dataView: DataView, offset: number) => boolean {
+  switch (duckdb.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: ${duckdb.sizeof_bool}`);
+  }
+}
+
+export const 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: number): number {
+  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: number): number {
+  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: number): number {
+  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: number): number {
+  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: number): number {
+  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: bigint): bigint {
+  if (BigInt.asIntN(64, value) !== value) {
+    throw new Error(`bigint out of int64 range`);
+  }
+  return value;
+}
+
+function checkUInt64(value: bigint): bigint {
+  if (BigInt.asUintN(64, value) !== value) {
+    throw new Error(`bigint out of uint64 range`);
+  }
+  return value;
+}
+
+function checkInt128(value: bigint): bigint {
+  if (BigInt.asIntN(128, value) !== value) {
+    throw new Error(`bigint out of int128 range`);
+  }
+  return value;
+}
+
+function checkUInt128(value: bigint): bigint {
+  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);
+// }
+
+export function setUInt8(dataView: DataView, offset: number, value: number) {
+  dataView.setUint8(offset, checkUInt8(value));
+}
+
+export function setInt16(dataView: DataView, offset: number, value: number) {
+  dataView.setInt16(offset, checkInt16(value), littleEndian);
+}
+
+export function setUInt16(dataView: DataView, offset: number, value: number) {
+  dataView.setUint16(offset, checkUInt16(value), littleEndian);
+}
+
+export function setInt32(dataView: DataView, offset: number, value: number) {
+  dataView.setInt32(offset, checkInt32(value), littleEndian);
+}
+
+export function setUInt32(dataView: DataView, offset: number, value: number) {
+  dataView.setUint32(offset, checkUInt32(value), littleEndian);
+}
+
+export function setInt64(dataView: DataView, offset: number, value: bigint) {
+  dataView.setBigInt64(offset, checkInt64(value), littleEndian);
+}
+
+export function setUInt64(dataView: DataView, offset: number, value: bigint) {
+  dataView.setBigUint64(offset, checkUInt64(value), littleEndian);
+}
+
+export function setInt128(dataView: DataView, offset: number, value: bigint) {
+  checkInt128(value);
+  const lower = BigInt.asUintN(64, value);
+  const upper = BigInt.asIntN(64, value >> BigInt(64));
+  dataView.setBigUint64(offset, lower, littleEndian);
+  dataView.setBigInt64(offset + 8, upper, littleEndian);
+}
+
+export function setUInt128(dataView: DataView, offset: number, value: bigint) {
+  checkUInt128(value);
+  const lower = BigInt.asUintN(64, value);
+  const upper = BigInt.asUintN(64, value >> BigInt(64));
+  dataView.setBigUint64(offset, lower, littleEndian);
+  dataView.setBigUint64(offset + 8, upper, littleEndian);
+}
+
+export function setBoolean1(dataView: DataView, offset: number, value: boolean) {
+  setUInt8(dataView, offset, value ? 1 : 0);
+}
+
+export function setBoolean2(dataView: DataView, offset: number, value: boolean) {
+  setUInt16(dataView, offset, value ? 1 : 0);
+}
+
+export function setBoolean4(dataView: DataView, offset: number, value: boolean) {
+  setUInt32(dataView, offset, value ? 1 : 0);
+}
+
+export function setBoolean8(dataView: DataView, offset: number, value: boolean) {
+  setUInt64(dataView, offset, value ? BigInt(1) : BigInt(0));
+}
+
+export function makeSetBoolean(): (
+  dataView: DataView,
+  offset: number,
+  value: boolean
+) => void {
+  switch (duckdb.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: ${duckdb.sizeof_bool}`);
+  }
+}
+
+export const setBoolean = makeSetBoolean();
+
+export function getDecimal16(
+  dataView: DataView,
+  offset: number,
+  type: DuckDBDecimalType
+): DuckDBDecimalValue {
+  const value = getInt16(dataView, offset);
+  return new DuckDBDecimalValue(BigInt(value), type.width, type.scale);
+}
+
+export function getDecimal32(
+  dataView: DataView,
+  offset: number,
+  type: DuckDBDecimalType
+): DuckDBDecimalValue {
+  const value = getInt32(dataView, offset);
+  return new DuckDBDecimalValue(BigInt(value), type.width, type.scale);
+}
+
+export function getDecimal64(
+  dataView: DataView,
+  offset: number,
+  type: DuckDBDecimalType
+): DuckDBDecimalValue {
+  const value = getInt64(dataView, offset);
+  return new DuckDBDecimalValue(value, type.width, type.scale);
+}
+
+export function getDecimal128(
+  dataView: DataView,
+  offset: number,
+  type: DuckDBDecimalType
+): DuckDBDecimalValue {
+  const value = getInt128(dataView, offset);
+  return new DuckDBDecimalValue(value, type.width, type.scale);
+}
+
+export function vectorData(vector: duckdb.Vector, byteCount: number): Uint8Array {
+  return duckdb.vector_get_data(vector, byteCount);
+}

package/vendor/node-api/src/vectors/index.ts

@@ -0,0 +1,50 @@
+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';
+
+// Side-effect import: registers the concrete DuckDBVector.create() factory.
+// Keep last so the base class and all subclasses are defined first.
+import './createVector';