@avidian/duckdb-bun 0.0.0-stage → 1.0.0

package/vendor/node-api/src/values/DuckDBTimestampSecondsValue.ts

@@ -0,0 +1,28 @@
+import duckdb, { TimestampSeconds } from "../../../../src/bindings/index.ts";
+import { getDuckDBTimestampStringFromSeconds } from '../conversion/dateTimeStringConversion';
+
+export class DuckDBTimestampSecondsValue implements TimestampSeconds {
+  public readonly seconds: bigint;
+
+  public constructor(seconds: bigint) {
+    this.seconds = seconds;
+  }
+
+  public get isFinite(): boolean {
+    return duckdb.is_finite_timestamp_s(this);
+  }
+
+  public toString(): string {
+    return getDuckDBTimestampStringFromSeconds(this.seconds);
+  }
+
+  public static readonly Epoch = new DuckDBTimestampSecondsValue(0n);
+  public static readonly Max = new DuckDBTimestampSecondsValue( 9223372036854n);
+  public static readonly Min = new DuckDBTimestampSecondsValue(-9223372022400n); // from test_all_types() select epoch(timestamp_s)::bigint;
+  public static readonly PosInf = new DuckDBTimestampSecondsValue(2n ** 63n - 1n);
+  public static readonly NegInf = new DuckDBTimestampSecondsValue(-(2n ** 63n - 1n));
+}
+
+export function timestampSecondsValue(seconds: bigint): DuckDBTimestampSecondsValue {
+  return new DuckDBTimestampSecondsValue(seconds);
+}

package/vendor/node-api/src/values/DuckDBTimestampTZNanosecondsValue.ts

@@ -0,0 +1,44 @@
+import duckdb, { TimestampNanoseconds } from "../../../../src/bindings/index.ts";
+import { getDuckDBTimestampStringFromNanoseconds } from '../conversion/dateTimeStringConversion';
+import { DuckDBTimestampNanosecondsValue } from './DuckDBTimestampNanosecondsValue';
+import { DuckDBTimestampTZValue } from './DuckDBTimestampTZValue';
+
+export class DuckDBTimestampTZNanosecondsValue implements TimestampNanoseconds {
+  public readonly nanos: bigint;
+
+  public constructor(nanos: bigint) {
+    this.nanos = nanos;
+  }
+
+  public get isFinite(): boolean {
+    return duckdb.is_finite_timestamp_ns(this);
+  }
+
+  /** Formats in the time zone set by `DuckDBTimestampTZValue.timezoneOffsetInMinutes`. */
+  public toString(): string {
+    return getDuckDBTimestampStringFromNanoseconds(
+      this.nanos,
+      DuckDBTimestampTZValue.timezoneOffsetInMinutes
+    );
+  }
+
+  public static readonly Epoch = new DuckDBTimestampTZNanosecondsValue(0n);
+  public static readonly Max = new DuckDBTimestampTZNanosecondsValue(
+    DuckDBTimestampNanosecondsValue.Max.nanos
+  );
+  public static readonly Min = new DuckDBTimestampTZNanosecondsValue(
+    DuckDBTimestampNanosecondsValue.Min.nanos
+  );
+  public static readonly PosInf = new DuckDBTimestampTZNanosecondsValue(
+    DuckDBTimestampNanosecondsValue.PosInf.nanos
+  );
+  public static readonly NegInf = new DuckDBTimestampTZNanosecondsValue(
+    DuckDBTimestampNanosecondsValue.NegInf.nanos
+  );
+}
+
+export function timestampTZNanosValue(
+  nanos: bigint
+): DuckDBTimestampTZNanosecondsValue {
+  return new DuckDBTimestampTZNanosecondsValue(nanos);
+}

package/vendor/node-api/src/values/DuckDBTimestampTZValue.ts

@@ -0,0 +1,54 @@
+import duckdb, { Timestamp, TimestampParts } from "../../../../src/bindings/index.ts";
+import { getDuckDBTimestampStringFromMicroseconds } from '../conversion/dateTimeStringConversion';
+import { DuckDBTimestampValue } from './DuckDBTimestampValue';
+
+export class DuckDBTimestampTZValue implements Timestamp {
+  public static timezoneOffsetInMinutes: number =
+    -new Date().getTimezoneOffset();
+
+  public readonly micros: bigint;
+
+  public constructor(micros: bigint) {
+    this.micros = micros;
+  }
+
+  public get isFinite(): boolean {
+    return duckdb.is_finite_timestamp(this);
+  }
+
+  public toString(): string {
+    return getDuckDBTimestampStringFromMicroseconds(
+      this.micros,
+      DuckDBTimestampTZValue.timezoneOffsetInMinutes
+    );
+  }
+
+  public toParts(): TimestampParts {
+    return duckdb.from_timestamp(this);
+  }
+
+  public static fromParts(parts: TimestampParts): DuckDBTimestampTZValue {
+    return new DuckDBTimestampTZValue(duckdb.to_timestamp(parts).micros);
+  }
+
+  public static readonly Epoch = new DuckDBTimestampTZValue(0n);
+  public static readonly Max = new DuckDBTimestampTZValue(
+    DuckDBTimestampValue.Max.micros
+  );
+  public static readonly Min = new DuckDBTimestampTZValue(
+    DuckDBTimestampValue.Min.micros
+  );
+  public static readonly PosInf = new DuckDBTimestampTZValue(
+    DuckDBTimestampValue.PosInf.micros
+  );
+  public static readonly NegInf = new DuckDBTimestampTZValue(
+    DuckDBTimestampValue.NegInf.micros
+  );
+}
+
+export function timestampTZValue(microsOrParts: bigint | TimestampParts): DuckDBTimestampTZValue {
+  if (typeof microsOrParts === 'bigint') {
+    return new DuckDBTimestampTZValue(microsOrParts);
+  }
+  return DuckDBTimestampTZValue.fromParts(microsOrParts);
+}

package/vendor/node-api/src/values/DuckDBTimestampValue.ts

@@ -0,0 +1,45 @@
+import duckdb, { Timestamp, TimestampParts } from "../../../../src/bindings/index.ts";
+import { getDuckDBTimestampStringFromMicroseconds } from '../conversion/dateTimeStringConversion';
+import { DuckDBTimestampMillisecondsValue } from './DuckDBTimestampMillisecondsValue';
+
+export type { TimestampParts };
+
+export class DuckDBTimestampValue implements Timestamp {
+  public readonly micros: bigint;
+
+  public constructor(micros: bigint) {
+    this.micros = micros;
+  }
+
+  public get isFinite(): boolean {
+    return duckdb.is_finite_timestamp(this);
+  }
+
+  public toString(): string {
+    return getDuckDBTimestampStringFromMicroseconds(this.micros);
+  }
+
+  public toParts(): TimestampParts {
+    return duckdb.from_timestamp(this);
+  }
+
+  public static fromParts(parts: TimestampParts): DuckDBTimestampValue {
+    return new DuckDBTimestampValue(duckdb.to_timestamp(parts).micros);
+  }
+  
+  public static readonly Epoch = new DuckDBTimestampValue(0n);
+  public static readonly Max = new DuckDBTimestampValue(2n ** 63n - 2n);
+  public static readonly Min = new DuckDBTimestampValue(DuckDBTimestampMillisecondsValue.Min.millis * 1000n);
+  public static readonly PosInf = new DuckDBTimestampValue(2n ** 63n - 1n);
+  public static readonly NegInf = new DuckDBTimestampValue(-(2n ** 63n - 1n));
+}
+
+export type DuckDBTimestampMicrosecondsValue = DuckDBTimestampValue;
+export const DuckDBTimestampMicrosecondsValue = DuckDBTimestampValue;
+
+export function timestampValue(microsOrParts: bigint | TimestampParts): DuckDBTimestampValue {
+  if (typeof microsOrParts === 'bigint') {
+    return new DuckDBTimestampValue(microsOrParts);
+  }
+  return DuckDBTimestampValue.fromParts(microsOrParts);
+}

package/vendor/node-api/src/values/DuckDBTupleValue.ts

@@ -0,0 +1,22 @@
+import { displayStringForDuckDBValue } from '../conversion/displayStringForDuckDBValue';
+import { DuckDBValue } from './DuckDBValue';
+
+/**
+ * A value of a tuple type: an unnamed STRUCT, such as `(1, 'a')` or
+ * `row(1, 'a')`. Its items are in entry order.
+ */
+export class DuckDBTupleValue {
+  public readonly items: readonly DuckDBValue[];
+
+  public constructor(items: readonly DuckDBValue[]) {
+    this.items = items;
+  }
+
+  public toString(): string {
+    return `(${this.items.map(displayStringForDuckDBValue).join(', ')})`;
+  }
+}
+
+export function tupleValue(items: readonly DuckDBValue[]): DuckDBTupleValue {
+  return new DuckDBTupleValue(items);
+}

package/vendor/node-api/src/values/DuckDBUUIDValue.ts

@@ -0,0 +1,48 @@
+export class DuckDBUUIDValue {
+  public readonly hugeint: bigint;
+
+  private constructor(hugeint: bigint) {
+    this.hugeint = hugeint;
+  }
+
+    /** Return the UUID as an unsigned 128-bit integer in a JS BigInt. */
+  public toUint128(): bigint {
+    // UUID values are stored with their MSB flipped so their numeric ordering matches their string ordering.
+    return (this.hugeint ^ 0x80000000000000000000000000000000n) & 0xffffffffffffffffffffffffffffffffn;
+  }
+
+  public toString(): string {
+    // Prepend with a (hex) 1 before converting to a hex string.
+    // This ensures the trailing 32 characters are the hex digits we want, left padded with zeros as needed.
+    const hex = (this.toUint128() | 0x100000000000000000000000000000000n).toString(16);
+    return `${hex.substring(1, 9)}-${hex.substring(9, 13)}-${hex.substring(13, 17)}-${hex.substring(17, 21)}-${hex.substring(21, 33)}`;
+  }
+
+  /** Create a DuckDBUUIDValue from an unsigned 128-bit integer in a JS BigInt. */
+  public static fromUint128(uint128: bigint): DuckDBUUIDValue {
+    // Convert the unsigned 128-bit input into DuckDB's storage form: MSB
+    // flipped (so numeric ordering matches string ordering) and held as a
+    // signed int128 (the same form `DuckDBUUIDVector` produces via
+    // `getInt128`).
+    return new DuckDBUUIDValue(
+      BigInt.asIntN(128, uint128 ^ 0x80000000000000000000000000000000n),
+    );
+  }
+
+  /**
+   * Create a DuckDBUUIDValue from a HUGEINT as stored by DuckDB.
+   *
+   * UUID values are stored with their MSB flipped so their numeric ordering matches their string ordering.
+   */
+  public static fromStoredHugeInt(hugeint: bigint): DuckDBUUIDValue {
+    return new DuckDBUUIDValue(hugeint);
+  }
+
+  public static readonly Max = new DuckDBUUIDValue(2n ** 127n - 1n); //  7fffffffffffffffffffffffffffffff
+  public static readonly Min = new DuckDBUUIDValue(-(2n ** 127n)); //  80000000000000000000000000000000
+}
+
+/** Create a DuckDBUUIDValue from an unsigned 128-bit integer in a JS BigInt. */
+export function uuidValue(uint128: bigint): DuckDBUUIDValue {
+  return DuckDBUUIDValue.fromUint128(uint128);
+}

package/vendor/node-api/src/values/DuckDBUnionValue.ts

@@ -0,0 +1,22 @@
+import { DuckDBValue } from './DuckDBValue';
+
+export class DuckDBUnionValue {
+  public readonly tag: string;
+  public readonly value: DuckDBValue;
+
+  public constructor(tag: string, value: DuckDBValue) {
+    this.tag = tag;
+    this.value = value;
+  }
+
+  public toString(): string {
+    if (this.value == null) {
+      return 'NULL';
+    }
+    return this.value.toString();
+  }
+}
+
+export function unionValue(tag: string, value: DuckDBValue): DuckDBUnionValue {
+  return new DuckDBUnionValue(tag, value);
+}

package/vendor/node-api/src/values/DuckDBValue.ts

@@ -0,0 +1,53 @@
+import { DuckDBArrayValue } from './DuckDBArrayValue';
+import { DuckDBBitValue } from './DuckDBBitValue';
+import { DuckDBBlobValue } from './DuckDBBlobValue';
+import { DuckDBDateValue } from './DuckDBDateValue';
+import { DuckDBDecimalValue } from './DuckDBDecimalValue';
+import { DuckDBGeometryValue } from './DuckDBGeometryValue';
+import { DuckDBIntervalValue } from './DuckDBIntervalValue';
+import { DuckDBListValue } from './DuckDBListValue';
+import { DuckDBMapValue } from './DuckDBMapValue';
+import { DuckDBStructValue } from './DuckDBStructValue';
+import { DuckDBTimeNSValue } from './DuckDBTimeNSValue';
+import { DuckDBTimestampMillisecondsValue } from './DuckDBTimestampMillisecondsValue';
+import { DuckDBTimestampNanosecondsValue } from './DuckDBTimestampNanosecondsValue';
+import { DuckDBTimestampSecondsValue } from './DuckDBTimestampSecondsValue';
+import { DuckDBTimestampTZValue } from './DuckDBTimestampTZValue';
+import { DuckDBTimestampTZNanosecondsValue } from './DuckDBTimestampTZNanosecondsValue';
+import { DuckDBTimestampValue } from './DuckDBTimestampValue';
+import { DuckDBTimeTZValue } from './DuckDBTimeTZValue';
+import { DuckDBTimeValue } from './DuckDBTimeValue';
+import { DuckDBTupleValue } from './DuckDBTupleValue';
+import { DuckDBUnionValue } from './DuckDBUnionValue';
+import { DuckDBUUIDValue } from './DuckDBUUIDValue';
+import { DuckDBVariantValue } from './DuckDBVariantValue';
+
+export type DuckDBValue =
+  | null
+  | boolean
+  | number
+  | bigint
+  | string
+  | DuckDBArrayValue
+  | DuckDBBitValue
+  | DuckDBBlobValue
+  | DuckDBDateValue
+  | DuckDBDecimalValue
+  | DuckDBGeometryValue
+  | DuckDBIntervalValue
+  | DuckDBListValue
+  | DuckDBMapValue
+  | DuckDBStructValue
+  | DuckDBTimestampMillisecondsValue
+  | DuckDBTimestampNanosecondsValue
+  | DuckDBTimestampSecondsValue
+  | DuckDBTimestampTZValue
+  | DuckDBTimestampTZNanosecondsValue
+  | DuckDBTimestampValue
+  | DuckDBTimeTZValue
+  | DuckDBTimeValue
+  | DuckDBTimeNSValue
+  | DuckDBTupleValue
+  | DuckDBUnionValue
+  | DuckDBUUIDValue
+  | DuckDBVariantValue;

package/vendor/node-api/src/values/DuckDBVariantValue.ts

@@ -0,0 +1,34 @@
+import { displayStringForDuckDBValue } from '../conversion/displayStringForDuckDBValue';
+// Type-only import avoids a runtime cycle with ../DuckDBType, which itself
+// pulls in the values barrel.
+import type { DuckDBType } from '../DuckDBType';
+import { DuckDBValue } from './DuckDBValue';
+
+/**
+ * Wraps a single decoded VARIANT row value. The wrapper distinguishes a
+ * SQL-NULL row (returned as bare `null`) from an embedded `VARIANT_NULL`
+ * tag (returned as `new DuckDBVariantValue(null)`).
+ *
+ * The optional `type` records the exact DuckDB type of the inner value
+ * (recovered from the on-disk variant tag at decode time). The append /
+ * bind paths use it so heterogeneous content round-trips faithfully —
+ * `typeForValue` is a best-effort fallback when `type` is not provided.
+ */
+export class DuckDBVariantValue {
+  public readonly value: DuckDBValue;
+  public readonly type?: DuckDBType;
+  public constructor(value: DuckDBValue, type?: DuckDBType) {
+    this.value = value;
+    this.type = type;
+  }
+  public toString(): string {
+    return displayStringForDuckDBValue(this.value);
+  }
+}
+
+export function variantValue(
+  value: DuckDBValue,
+  type?: DuckDBType,
+): DuckDBVariantValue {
+  return new DuckDBVariantValue(value, type);
+}

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

@@ -0,0 +1,24 @@
+export * from './DuckDBArrayValue';
+export * from './DuckDBBitValue';
+export * from './DuckDBBlobValue';
+export * from './DuckDBDateValue';
+export * from './DuckDBDecimalValue';
+export * from './DuckDBGeometryValue';
+export * from './DuckDBIntervalValue';
+export * from './DuckDBListValue';
+export * from './DuckDBMapValue';
+export * from './DuckDBStructValue';
+export * from './DuckDBTimeNSValue';
+export * from './DuckDBTimestampMillisecondsValue';
+export * from './DuckDBTimestampNanosecondsValue';
+export * from './DuckDBTimestampSecondsValue';
+export * from './DuckDBTimestampTZValue';
+export * from './DuckDBTimestampTZNanosecondsValue';
+export * from './DuckDBTimestampValue';
+export * from './DuckDBTimeTZValue';
+export * from './DuckDBTimeValue';
+export * from './DuckDBTupleValue';
+export * from './DuckDBUnionValue';
+export * from './DuckDBUUIDValue';
+export * from './DuckDBValue';
+export * from './DuckDBVariantValue';

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

@@ -0,0 +1,107 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBArrayType,
+} from '../DuckDBType';
+import {
+  DuckDBArrayValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+
+export class DuckDBArrayVector extends DuckDBVector<DuckDBArrayValue> {
+  private readonly arrayType: DuckDBArrayType;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  private readonly childData: DuckDBVector;
+  private readonly _itemCount: number;
+  constructor(
+    arrayType: DuckDBArrayType,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector,
+    childData: DuckDBVector,
+    itemCount: number
+  ) {
+    super();
+    this.arrayType = arrayType;
+    this.validity = validity;
+    this.vector = vector;
+    this.childData = childData;
+    this._itemCount = itemCount;
+  }
+  static fromRawVector(
+    arrayType: DuckDBArrayType,
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBArrayVector {
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    const child_vector = duckdb.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,
+      vector,
+      childData,
+      itemCount
+    );
+  }
+  private static itemSize(arrayType: DuckDBArrayType): number {
+    if (arrayType.valueType instanceof DuckDBArrayType) {
+      return DuckDBArrayVector.itemSize(arrayType.valueType);
+    } else {
+      return 1;
+    }
+  }
+  public override get type(): DuckDBArrayType {
+    return this.arrayType;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(itemIndex: number): DuckDBArrayValue | null {
+    if (!this.validity.itemValid(itemIndex)) {
+      return null;
+    }
+    return new DuckDBArrayValue(
+      this.childData
+        .slice(itemIndex * this.arrayType.length, this.arrayType.length)
+        .toArray()
+    );
+  }
+  public override setItem(itemIndex: number, value: DuckDBArrayValue | null) {
+    if (value != null) {
+      const startIndex = itemIndex * this.arrayType.length;
+      for (let i = 0; i < this.arrayType.length; i++) {
+        this.childData.setItem(startIndex + i, value.items[i]);
+      }
+      this.validity.setItemValid(itemIndex, true);
+    } else {
+      const startIndex = itemIndex * this.arrayType.length;
+      for (let i = 0; i < this.arrayType.length; i++) {
+        this.childData.setItem(startIndex + i, null);
+      }
+      this.validity.setItemValid(itemIndex, false);
+    }
+  }
+  public override flush() {
+    this.childData.flush();
+    this.validity.flush(this.vector);
+  }
+  public override slice(offset: number, length: number): DuckDBArrayVector {
+    return new DuckDBArrayVector(
+      this.arrayType,
+      this.validity.slice(offset, length),
+      this.vector,
+      this.childData.slice(
+        offset * this.arrayType.length,
+        length * this.arrayType.length
+      ),
+      length
+    );
+  }
+}

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

@@ -0,0 +1,75 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBBigIntType,
+} from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBBigIntVector extends DuckDBVector<bigint> {
+  private readonly items: BigInt64Array;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  constructor(
+    items: BigInt64Array,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector
+  ) {
+    super();
+    this.items = items;
+    this.validity = validity;
+    this.vector = vector;
+  }
+  static fromRawVector(
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBBigIntVector {
+    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, vector);
+  }
+  public override get type(): DuckDBBigIntType {
+    return DuckDBBigIntType.instance;
+  }
+  public override get itemCount(): number {
+    return this.items.length;
+  }
+  public override getItem(itemIndex: number): bigint | null {
+    return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+  }
+  public override setItem(itemIndex: number, value: bigint | null) {
+    if (value != null) {
+      // Checked inline for bulk-write throughput; see dataAccessors.ts.
+      if (BigInt.asIntN(64, value) !== value) {
+        throw new Error(`bigint out of int64 range`);
+      }
+      this.items[itemIndex] = value;
+      this.validity.setItemValid(itemIndex, true);
+    } else {
+      this.validity.setItemValid(itemIndex, false);
+    }
+  }
+  public override flush() {
+    duckdb.copy_data_to_vector(
+      this.vector,
+      0,
+      this.items.buffer as ArrayBuffer,
+      this.items.byteOffset,
+      this.items.byteLength
+    );
+    this.validity.flush(this.vector);
+  }
+  public override slice(offset: number, length: number): DuckDBBigIntVector {
+    return new DuckDBBigIntVector(
+      this.items.slice(offset, offset + length),
+      this.validity.slice(offset, length),
+      this.vector
+    );
+  }
+}

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

@@ -0,0 +1,98 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBBigNumType,
+} from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  getBigNumFromBytes,
+  getBytesFromBigNum,
+  getStringBytes,
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBBigNumVector extends DuckDBVector<bigint> {
+  private readonly dataView: DataView;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  private readonly itemOffset: number;
+  private readonly _itemCount: number;
+  private readonly itemCache: (bigint | null | undefined)[];
+  private readonly itemCacheDirty: boolean[];
+  constructor(
+    dataView: DataView,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector,
+    itemOffset: number,
+    itemCount: number
+  ) {
+    super();
+    this.dataView = dataView;
+    this.validity = validity;
+    this.vector = vector;
+    this.itemOffset = itemOffset;
+    this._itemCount = itemCount;
+    this.itemCache = [];
+    this.itemCacheDirty = [];
+  }
+  static fromRawVector(
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBBigNumVector {
+    const data = vectorData(vector, itemCount * 16);
+    const dataView = new DataView(
+      data.buffer,
+      data.byteOffset,
+      data.byteLength
+    );
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBBigNumVector(dataView, validity, vector, 0, itemCount);
+  }
+  public override get type(): DuckDBBigNumType {
+    return DuckDBBigNumType.instance;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(itemIndex: number): bigint | null {
+    if (!this.validity.itemValid(itemIndex)) {
+      return null;
+    }
+    const bytes = getStringBytes(this.dataView, itemIndex * 16);
+    return bytes ? getBigNumFromBytes(bytes) : null;
+  }
+  public override setItem(itemIndex: number, value: bigint | null) {
+    this.itemCache[itemIndex] = value;
+    this.validity.setItemValid(itemIndex, value != null);
+    this.itemCacheDirty[itemIndex] = true;
+  }
+  public override flush() {
+    for (let itemIndex = 0; itemIndex < this._itemCount; itemIndex++) {
+      if (this.itemCacheDirty[itemIndex]) {
+        const cachedItem = this.itemCache[itemIndex];
+        if (cachedItem !== undefined && cachedItem !== null) {
+          duckdb.vector_assign_string_element_len(
+            this.vector,
+            this.itemOffset + itemIndex,
+            getBytesFromBigNum(cachedItem)
+          );
+        }
+        this.itemCacheDirty[itemIndex] = false;
+      }
+    }
+    this.validity.flush(this.vector);
+  }
+  public override slice(offset: number, length: number): DuckDBBigNumVector {
+    return new DuckDBBigNumVector(
+      new DataView(
+        this.dataView.buffer,
+        this.dataView.byteOffset + offset * 16,
+        length * 16
+      ),
+      this.validity.slice(offset, length),
+      this.vector,
+      offset,
+      length
+    );
+  }
+}