@avidian/duckdb-bun 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,75 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBIntegerType,
+} from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBIntegerVector extends DuckDBVector<number> {
+  private readonly items: Int32Array;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  constructor(
+    items: Int32Array,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector
+  ) {
+    super();
+    this.items = items;
+    this.validity = validity;
+    this.vector = vector;
+  }
+  static fromRawVector(
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBIntegerVector {
+    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, vector);
+  }
+  public override get type(): DuckDBIntegerType {
+    return DuckDBIntegerType.instance;
+  }
+  public override get itemCount(): number {
+    return this.items.length;
+  }
+  public override getItem(itemIndex: number): number | null {
+    return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+  }
+  public setItem(itemIndex: number, value: number | null) {
+    if (value != null) {
+      // Checked inline for bulk-write throughput; see dataAccessors.ts.
+      if (!Number.isInteger(value)) {
+        throw new Error(`number is not an integer`);
+      }
+      if (value < -2147483648 || value > 2147483647) {
+        throw new Error(`number out of int32 range`);
+      }
+      this.items[itemIndex] = value;
+      this.validity.setItemValid(itemIndex, true);
+    } else {
+      this.validity.setItemValid(itemIndex, false);
+    }
+  }
+  public 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): DuckDBIntegerVector {
+    return new DuckDBIntegerVector(
+      this.items.slice(offset, offset + length),
+      this.validity.slice(offset, length),
+      this.vector
+    );
+  }
+}

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

@@ -0,0 +1,100 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBIntervalType,
+} from '../DuckDBType';
+import {
+  DuckDBIntervalValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  getInt32,
+  getInt64,
+  setInt32,
+  setInt64,
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBIntervalVector extends DuckDBVector<DuckDBIntervalValue> {
+  private readonly dataView: DataView;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  private readonly _itemCount: number;
+  constructor(
+    dataView: DataView,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector,
+    itemCount: number
+  ) {
+    super();
+    this.dataView = dataView;
+    this.validity = validity;
+    this.vector = vector;
+    this._itemCount = itemCount;
+  }
+  static fromRawVector(
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBIntervalVector {
+    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, vector, itemCount);
+  }
+  public override get type(): DuckDBIntervalType {
+    return DuckDBIntervalType.instance;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(itemIndex: number): DuckDBIntervalValue | null {
+    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 DuckDBIntervalValue(months, days, micros);
+  }
+  public override setItem(
+    itemIndex: number,
+    value: DuckDBIntervalValue | null
+  ) {
+    if (value != null) {
+      const itemStart = itemIndex * 16;
+      setInt32(this.dataView, itemStart, value.months);
+      setInt32(this.dataView, itemStart + 4, value.days);
+      setInt64(this.dataView, itemStart + 8, value.micros);
+      this.validity.setItemValid(itemIndex, true);
+    } else {
+      this.validity.setItemValid(itemIndex, false);
+    }
+  }
+  public override flush() {
+    duckdb.copy_data_to_vector(
+      this.vector,
+      0,
+      this.dataView.buffer as ArrayBuffer,
+      this.dataView.byteOffset,
+      this.dataView.byteLength
+    );
+    this.validity.flush(this.vector);
+  }
+  public override slice(offset: number, length: number): DuckDBIntervalVector {
+    return new DuckDBIntervalVector(
+      new DataView(
+        this.dataView.buffer,
+        this.dataView.byteOffset + offset * 16,
+        length * 16
+      ),
+      this.validity.slice(offset, length),
+      this.vector,
+      length
+    );
+  }
+}

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

@@ -0,0 +1,221 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBListType,
+} from '../DuckDBType';
+import {
+  DuckDBListValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBListVector extends DuckDBVector<DuckDBListValue> {
+  private readonly parentList: DuckDBListVector | null;
+  private readonly listType: DuckDBListType;
+  private readonly entryData: BigUint64Array;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  private childData: DuckDBVector;
+  private readonly itemOffset: number;
+  private readonly _itemCount: number;
+  private readonly itemCache: (DuckDBListValue | null | undefined)[];
+  constructor(
+    parentList: DuckDBListVector | null,
+    listType: DuckDBListType,
+    entryData: BigUint64Array,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector,
+    childData: DuckDBVector,
+    itemOffset: number,
+    itemCount: number
+  ) {
+    super();
+    this.parentList = parentList;
+    this.listType = listType;
+    this.entryData = entryData;
+    this.validity = validity;
+    this.vector = vector;
+    this.childData = childData;
+    this.itemOffset = itemOffset;
+    this._itemCount = itemCount;
+    this.itemCache = [];
+  }
+  static fromRawVector(
+    listType: DuckDBListType,
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBListVector {
+    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 = duckdb.list_vector_get_child(vector);
+    const child_vector_size = duckdb.list_vector_get_size(vector);
+    const childData = DuckDBVector.create(
+      child_vector,
+      child_vector_size,
+      listType.valueType
+    );
+
+    return new DuckDBListVector(
+      null,
+      listType,
+      entryData,
+      validity,
+      vector,
+      childData,
+      0,
+      itemCount
+    );
+  }
+  public override get type(): DuckDBListType {
+    return this.listType;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public getItemVector(itemIndex: number): DuckDBVector | null {
+    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);
+  }
+  /**
+   * Returns the offset into `childVector` where this row's elements begin.
+   * Combined with `childVector`, this allows callers to index directly into
+   * the flat backing storage without allocating a per-row sliced vector.
+   */
+  public getEntryOffset(itemIndex: number): number {
+    return Number(this.entryData[itemIndex * 2]);
+  }
+  /** Returns the number of elements this row contributes to `childVector`. */
+  public getEntryLength(itemIndex: number): number {
+    return Number(this.entryData[itemIndex * 2 + 1]);
+  }
+  /** The (flat) child vector backing all rows' list elements. */
+  public get childVector(): DuckDBVector {
+    return this.childData;
+  }
+  public override getItem(itemIndex: number): DuckDBListValue | null {
+    const cachedItem = this.itemCache[itemIndex];
+    if (cachedItem !== undefined) {
+      return cachedItem;
+    }
+    const vector = this.getItemVector(itemIndex);
+    if (!vector) {
+      return null;
+    }
+    const item = new DuckDBListValue(vector.toArray());
+    this.itemCache[itemIndex] = item;
+    return item;
+  }
+  public setItem(itemIndex: number, value: DuckDBListValue | null) {
+    this.itemCache[itemIndex] = value;
+    if (this.parentList) {
+      this.parentList.setItem(this.itemOffset + itemIndex, value);
+    } else {
+      this.validity.setItemValid(itemIndex, value != null);
+    }
+  }
+  public flush() {
+    if (this.parentList) {
+      this.parentList.flush();
+      for (let i = 0; i < this.itemCount; i++) {
+        this.itemCache[i] = undefined;
+      }
+    } else {
+      // update entryData offset & lengths
+      // calculate new child vector size (sum of all item lengths)
+      let totalLength = 0;
+      for (let itemIndex = 0; itemIndex < this._itemCount; itemIndex++) {
+        const entryDataStartIndex = itemIndex * 2;
+        this.entryData[entryDataStartIndex] = BigInt(totalLength);
+        // ensure the cache is populated for all items
+        const item = this.getItem(itemIndex);
+        if (item) {
+          this.entryData[entryDataStartIndex + 1] = BigInt(item.items.length);
+          totalLength += item.items.length;
+        } else {
+          this.entryData[entryDataStartIndex + 1] = 0n;
+        }
+      }
+
+      // grow child vector capacity (set_size does not allocate)
+      duckdb.list_vector_reserve(this.vector, totalLength);
+
+      // set new child vector size
+      duckdb.list_vector_set_size(this.vector, totalLength);
+
+      // recreate childData after resize
+      const child_vector = duckdb.list_vector_get_child(this.vector);
+      const child_vector_size = duckdb.list_vector_get_size(this.vector);
+      this.childData = DuckDBVector.create(
+        child_vector,
+        child_vector_size,
+        this.listType.valueType
+      );
+
+      // set all childData items
+      let childItemAbsoluteIndex = 0;
+      for (let listIndex = 0; listIndex < this._itemCount; listIndex++) {
+        const list = this.getItem(listIndex);
+        if (list) {
+          for (
+            let childItemRelativeIndex = 0;
+            childItemRelativeIndex < list.items.length;
+            childItemRelativeIndex++
+          ) {
+            this.childData.setItem(
+              childItemAbsoluteIndex++,
+              list.items[childItemRelativeIndex]
+            );
+          }
+        }
+      }
+
+      // copy childData to child vector
+      this.childData.flush();
+
+      // copy entryData to vector
+      duckdb.copy_data_to_vector(
+        this.vector,
+        0,
+        this.entryData.buffer as ArrayBuffer,
+        this.entryData.byteOffset,
+        this.entryData.byteLength
+      );
+
+      // flush validity
+      this.validity.flush(this.vector);
+    }
+  }
+  public override slice(offset: number, length: number): DuckDBListVector {
+    const entryDataStartIndex = offset * 2;
+    return new DuckDBListVector(
+      this,
+      this.listType,
+      this.entryData.slice(
+        entryDataStartIndex,
+        entryDataStartIndex + length * 2
+      ),
+      this.validity.slice(offset, length),
+      this.vector,
+      this.childData,
+      offset,
+      length
+    );
+  }
+}

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

@@ -0,0 +1,88 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBListType,
+  DuckDBMapType,
+  DuckDBStructType,
+} from '../DuckDBType';
+import {
+  DuckDBMapEntry,
+  DuckDBMapValue,
+  listValue,
+  structValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBListVector } from './DuckDBListVector';
+import { DuckDBStructVector } from './DuckDBStructVector';
+
+// MAP = LIST(STRUCT(key KEY_TYPE, value VALUE_TYPE))
+export class DuckDBMapVector extends DuckDBVector<DuckDBMapValue> {
+  private readonly mapType: DuckDBMapType;
+  private readonly listVector: DuckDBListVector;
+  constructor(mapType: DuckDBMapType, listVector: DuckDBListVector) {
+    super();
+    this.mapType = mapType;
+    this.listVector = listVector;
+  }
+  static fromRawVector(
+    mapType: DuckDBMapType,
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBMapVector {
+    const listVectorType = new DuckDBListType(
+      new DuckDBStructType(
+        ['key', 'value'],
+        [mapType.keyType, mapType.valueType]
+      )
+    );
+    return new DuckDBMapVector(
+      mapType,
+      DuckDBListVector.fromRawVector(listVectorType, vector, itemCount)
+    );
+  }
+  public override get type(): DuckDBMapType {
+    return this.mapType;
+  }
+  public override get itemCount(): number {
+    return this.listVector.itemCount;
+  }
+  public override getItem(itemIndex: number): DuckDBMapValue | null {
+    const itemVector = this.listVector.getItemVector(itemIndex);
+    if (!itemVector) {
+      return null;
+    }
+    if (!(itemVector instanceof DuckDBStructVector)) {
+      throw new Error('item in map list vector is not a struct');
+    }
+    const entries: DuckDBMapEntry[] = [];
+    const itemEntryCount = itemVector.itemCount;
+    for (let i = 0; i < itemEntryCount; i++) {
+      const key = itemVector.getItemValue(i, 0);
+      const value = itemVector.getItemValue(i, 1);
+      entries.push({ key, value });
+    }
+    return new DuckDBMapValue(entries);
+  }
+  public override setItem(itemIndex: number, value: DuckDBMapValue | null) {
+    if (value != null) {
+      this.listVector.setItem(
+        itemIndex,
+        listValue(
+          value.entries.map((entry) =>
+            structValue({ 'key': entry.key, 'value': entry.value })
+          )
+        )
+      );
+    } else {
+      this.listVector.setItem(itemIndex, null);
+    }
+  }
+  public override flush() {
+    this.listVector.flush();
+  }
+  public override slice(offset: number, length: number): DuckDBMapVector {
+    return new DuckDBMapVector(
+      this.mapType,
+      this.listVector.slice(offset, length)
+    );
+  }
+}

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

@@ -0,0 +1,53 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import { DuckDBSQLNullType } from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+
+/** A vector of the SQLNULL type, whose items are all null. */
+export class DuckDBSQLNullVector extends DuckDBVector<null> {
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  private readonly _itemCount: number;
+  constructor(
+    validity: DuckDBValidity,
+    vector: duckdb.Vector,
+    itemCount: number
+  ) {
+    super();
+    this.validity = validity;
+    this.vector = vector;
+    this._itemCount = itemCount;
+  }
+  static fromRawVector(
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBSQLNullVector {
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBSQLNullVector(validity, vector, itemCount);
+  }
+  public override get type(): DuckDBSQLNullType {
+    return DuckDBSQLNullType.instance;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(_itemIndex: number): null {
+    return null;
+  }
+  public override setItem(itemIndex: number, value: null) {
+    if (value !== null) {
+      throw new Error(`Cannot set a non-null value in a SQLNULL vector`);
+    }
+    this.validity.setItemValid(itemIndex, false);
+  }
+  public override flush() {
+    this.validity.flush(this.vector);
+  }
+  public override slice(offset: number, length: number): DuckDBSQLNullVector {
+    return new DuckDBSQLNullVector(
+      this.validity.slice(offset, length),
+      this.vector,
+      length
+    );
+  }
+}

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

@@ -0,0 +1,75 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBSmallIntType,
+} from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBSmallIntVector extends DuckDBVector<number> {
+  private readonly items: Int16Array;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  constructor(
+    items: Int16Array,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector
+  ) {
+    super();
+    this.items = items;
+    this.validity = validity;
+    this.vector = vector;
+  }
+  static fromRawVector(
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBSmallIntVector {
+    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, vector);
+  }
+  public override get type(): DuckDBSmallIntType {
+    return DuckDBSmallIntType.instance;
+  }
+  public override get itemCount(): number {
+    return this.items.length;
+  }
+  public override getItem(itemIndex: number): number | null {
+    return this.validity.itemValid(itemIndex) ? this.items[itemIndex] : null;
+  }
+  public override setItem(itemIndex: number, value: number | null) {
+    if (value != null) {
+      // Checked inline for bulk-write throughput; see dataAccessors.ts.
+      if (!Number.isInteger(value)) {
+        throw new Error(`number is not an integer`);
+      }
+      if (value < -32768 || value > 32767) {
+        throw new Error(`number out of int16 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): DuckDBSmallIntVector {
+    return new DuckDBSmallIntVector(
+      this.items.slice(offset, offset + length),
+      this.validity.slice(offset, length),
+      this.vector
+    );
+  }
+}