@avidian/duckdb-bun 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,75 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBUSmallIntType,
+} from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBUSmallIntVector extends DuckDBVector<number> {
+  private readonly items: Uint16Array;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  constructor(
+    items: Uint16Array,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector
+  ) {
+    super();
+    this.items = items;
+    this.validity = validity;
+    this.vector = vector;
+  }
+  static fromRawVector(
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBUSmallIntVector {
+    const data = vectorData(vector, itemCount * Uint16Array.BYTES_PER_ELEMENT);
+    const items = new Uint16Array(data.buffer, data.byteOffset, itemCount);
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBUSmallIntVector(items, validity, vector);
+  }
+  public override get type(): DuckDBUSmallIntType {
+    return DuckDBUSmallIntType.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 < 0 || value > 65535) {
+        throw new Error(`number out of uint16 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): DuckDBUSmallIntVector {
+    return new DuckDBUSmallIntVector(
+      this.items.slice(offset, offset + length),
+      this.validity.slice(offset, length),
+      this.vector
+    );
+  }
+}

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

@@ -0,0 +1,75 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBUTinyIntType,
+} from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBUTinyIntVector extends DuckDBVector<number> {
+  private readonly items: Uint8Array;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  constructor(
+    items: Uint8Array,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector
+  ) {
+    super();
+    this.items = items;
+    this.validity = validity;
+    this.vector = vector;
+  }
+  static fromRawVector(
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBUTinyIntVector {
+    const data = vectorData(vector, itemCount * Uint8Array.BYTES_PER_ELEMENT);
+    const items = new Uint8Array(data.buffer, data.byteOffset, itemCount);
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBUTinyIntVector(items, validity, vector);
+  }
+  public override get type(): DuckDBUTinyIntType {
+    return DuckDBUTinyIntType.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 < 0 || value > 255) {
+        throw new Error(`number out of uint8 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): DuckDBUTinyIntVector {
+    return new DuckDBUTinyIntVector(
+      this.items.slice(offset, offset + length),
+      this.validity.slice(offset, length),
+      this.vector
+    );
+  }
+}

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

@@ -0,0 +1,89 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBUUIDType,
+} from '../DuckDBType';
+import {
+  DuckDBUUIDValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  getInt128,
+  setInt128,
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBUUIDVector extends DuckDBVector<DuckDBUUIDValue> {
+  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
+  ): DuckDBUUIDVector {
+    const data = vectorData(vector, itemCount * 16);
+    const dataView = new DataView(
+      data.buffer,
+      data.byteOffset,
+      data.byteLength
+    );
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBUUIDVector(dataView, validity, vector, itemCount);
+  }
+  public override get type(): DuckDBUUIDType {
+    return DuckDBUUIDType.instance;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(itemIndex: number): DuckDBUUIDValue | null {
+    return this.validity.itemValid(itemIndex)
+      ? DuckDBUUIDValue.fromStoredHugeInt(
+          getInt128(this.dataView, itemIndex * 16)
+        )
+      : null;
+  }
+  public override setItem(itemIndex: number, value: DuckDBUUIDValue | null) {
+    if (value != null) {
+      setInt128(this.dataView, itemIndex * 16, value.hugeint);
+      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): DuckDBUUIDVector {
+    return new DuckDBUUIDVector(
+      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/DuckDBUnionVector.ts

@@ -0,0 +1,84 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBStructType,
+  DuckDBType,
+  DuckDBUTinyIntType,
+  DuckDBUnionType,
+} from '../DuckDBType';
+import {
+  DuckDBUnionValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBStructVector } from './DuckDBStructVector';
+
+// UNION = STRUCT with first entry named "tag"
+export class DuckDBUnionVector extends DuckDBVector<DuckDBUnionValue> {
+  private readonly unionType: DuckDBUnionType;
+  private readonly structVector: DuckDBStructVector;
+  constructor(unionType: DuckDBUnionType, structVector: DuckDBStructVector) {
+    super();
+    this.unionType = unionType;
+    this.structVector = structVector;
+  }
+  static fromRawVector(
+    unionType: DuckDBUnionType,
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBUnionVector {
+    const entryNames: string[] = ['tag'];
+    const entryTypes: DuckDBType[] = [DuckDBUTinyIntType.instance];
+    const memberCount = unionType.memberCount;
+    for (let i = 0; i < memberCount; i++) {
+      entryNames.push(unionType.memberTags[i]);
+      entryTypes.push(unionType.memberTypes[i]);
+    }
+    const structVectorType = new DuckDBStructType(entryNames, entryTypes);
+    return new DuckDBUnionVector(
+      unionType,
+      DuckDBStructVector.fromRawVector(structVectorType, vector, itemCount)
+    );
+  }
+  public override get type(): DuckDBUnionType {
+    return this.unionType;
+  }
+  public override get itemCount(): number {
+    return this.structVector.itemCount;
+  }
+  public override getItem(itemIndex: number): DuckDBUnionValue | null {
+    const tagValue = this.structVector.getItemValue(itemIndex, 0);
+    if (tagValue == null) {
+      return null;
+    }
+    const memberIndex = Number(tagValue);
+    const tag = this.unionType.memberTags[memberIndex];
+    const entryIndex = memberIndex + 1;
+    const value = this.structVector.getItemValue(itemIndex, entryIndex);
+    return new DuckDBUnionValue(tag, value);
+  }
+  public override setItem(itemIndex: number, value: DuckDBUnionValue | null) {
+    if (value != null) {
+      const memberIndex = this.unionType.memberIndexForTag(value.tag);
+      this.structVector.setItemValue(itemIndex, 0, memberIndex);
+      const entryIndex = memberIndex + 1;
+      this.structVector.setItemValue(itemIndex, entryIndex, value.value);
+      for (let i = 1; i <= this.unionType.memberCount; i++) {
+        if (i !== entryIndex) {
+          this.structVector.setItemValue(itemIndex, i, null);
+        }
+      }
+    } else {
+      for (let i = 0; i <= this.unionType.memberCount; i++) {
+        this.structVector.setItemValue(itemIndex, i, null);
+      }
+    }
+  }
+  public override flush() {
+    this.structVector.flush();
+  }
+  public override slice(offset: number, length: number): DuckDBUnionVector {
+    return new DuckDBUnionVector(
+      this.unionType,
+      this.structVector.slice(offset, length)
+    );
+  }
+}

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

@@ -0,0 +1,104 @@
+import duckdb from "../../../../src/bindings/index.ts";
+
+// This version of DuckDBValidity is almost 10x slower.
+// class DuckDBValidity {
+//   private readonly validity_pointer: ddb.uint64_pointer;
+//   private readonly offset: number;
+//   private constructor(validity_pointer: ddb.uint64_pointer, offset: number = 0) {
+//     this.validity_pointer = validity_pointer;
+//     this.offset = offset;
+//   }
+//   public static fromVector(vector: ddb.duckdb_vector, itemCount: number, offset: number = 0): DuckDBValidity {
+//     const validity_pointer = ddb.duckdb_vector_get_validity(vector);
+//     return new DuckDBValidity(validity_pointer, offset);
+//   }
+//   public itemValid(itemIndex: number): boolean {
+//     return ddb.duckdb_validity_row_is_valid(this.validity_pointer, this.offset + itemIndex);
+//   }
+//   public slice(offset: number): DuckDBValidity {
+//     return new DuckDBValidity(this.validity_pointer, this.offset + offset);
+//   }
+// }
+
+export class DuckDBValidity {
+  private data: BigUint64Array | null;
+  private readonly offset: number;
+  private readonly itemCount: number;
+  private constructor(
+    data: BigUint64Array | null,
+    offset: number,
+    itemCount: number
+  ) {
+    this.data = data;
+    this.offset = offset;
+    this.itemCount = itemCount;
+  }
+  public static fromVector(
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBValidity {
+    const uint64Count = Math.ceil(itemCount / 64);
+    const bytes = duckdb.vector_get_validity(vector, uint64Count * 8);
+    if (!bytes) {
+      return new DuckDBValidity(null, 0, itemCount);
+    }
+    const bigints = new BigUint64Array(
+      bytes.buffer,
+      bytes.byteOffset,
+      uint64Count
+    );
+    return new DuckDBValidity(bigints, 0, itemCount);
+  }
+  public itemValid(itemIndex: number): boolean {
+    if (!this.data) {
+      return true;
+    }
+    const bit = this.offset + itemIndex;
+    return (
+      (this.data[Math.floor(bit / 64)] & (BigInt(1) << BigInt(bit % 64))) !==
+      BigInt(0)
+    );
+  }
+  public setItemValid(itemIndex: number, valid: boolean) {
+    if (!this.data && !valid) {
+      // An item is being set to invalid and we don't have a data buffer, so create it. If an item is being set to valid
+      // and we don't have a data buffer, then there's nothing to do; a null data buffer indicates all items are valid.
+      const uint64Count = Math.ceil(this.itemCount / 64);
+      const buffer = new ArrayBuffer(uint64Count * 8);
+      this.data = new BigUint64Array(buffer, 0, uint64Count);
+      // Initialize to all items to valid.
+      for (let i = 0; i < this.data.length; i++) {
+        this.data[i] = 0xffffffffffffffffn;
+      }
+    }
+    if (this.data) {
+      const bit = this.offset + itemIndex;
+      const uint64Index = Math.floor(bit / 64);
+      const uint64WithBitSet = BigInt(1) << BigInt(bit % 64);
+      if (valid) {
+        if ((this.data[uint64Index] & uint64WithBitSet) === 0n) {
+          this.data[uint64Index] |= uint64WithBitSet;
+        }
+      } else {
+        if ((this.data[uint64Index] & uint64WithBitSet) !== 0n) {
+          this.data[uint64Index] &= ~uint64WithBitSet;
+        }
+      }
+    }
+  }
+  public flush(vector: duckdb.Vector) {
+    if (this.data) {
+      duckdb.vector_ensure_validity_writable(vector);
+      duckdb.copy_data_to_vector_validity(
+        vector,
+        0,
+        this.data.buffer as ArrayBuffer,
+        this.data.byteOffset,
+        this.data.byteLength
+      );
+    }
+  }
+  public slice(offset: number, itemCount: number): DuckDBValidity {
+    return new DuckDBValidity(this.data, this.offset + offset, itemCount);
+  }
+}

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

@@ -0,0 +1,100 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBVarCharType,
+} from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  getString,
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBVarCharVector extends DuckDBVector<string> {
+  private readonly dataView: DataView;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  private readonly itemOffset: number;
+  private readonly _itemCount: number;
+  private readonly itemCache: (string | 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
+  ): DuckDBVarCharVector {
+    const data = vectorData(vector, itemCount * 16);
+    const dataView = new DataView(
+      data.buffer,
+      data.byteOffset,
+      data.byteLength
+    );
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBVarCharVector(dataView, validity, vector, 0, itemCount);
+  }
+  public override get type(): DuckDBVarCharType {
+    return DuckDBVarCharType.instance;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(itemIndex: number): string | null {
+    const cachedItem = this.itemCache[itemIndex];
+    if (cachedItem !== undefined) {
+      return cachedItem;
+    }
+    const item = this.validity.itemValid(itemIndex)
+      ? getString(this.dataView, itemIndex * 16)
+      : null;
+    this.itemCache[itemIndex] = item;
+    return item;
+  }
+  public setItem(itemIndex: number, value: string | null) {
+    this.itemCache[itemIndex] = value;
+    this.validity.setItemValid(itemIndex, value != null);
+    this.itemCacheDirty[itemIndex] = true;
+  }
+  public 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(
+            this.vector,
+            this.itemOffset + itemIndex,
+            cachedItem
+          );
+        }
+        this.itemCacheDirty[itemIndex] = false;
+      }
+    }
+    this.validity.flush(this.vector);
+  }
+  public override slice(offset: number, length: number): DuckDBVarCharVector {
+    return new DuckDBVarCharVector(
+      new DataView(
+        this.dataView.buffer,
+        this.dataView.byteOffset + offset * 16,
+        length * 16
+      ),
+      this.validity.slice(offset, length),
+      this.vector,
+      offset,
+      length
+    );
+  }
+}