@avidian/duckdb-bun 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,102 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBBitType,
+} from '../DuckDBType';
+import {
+  DuckDBBitValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  getBuffer,
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBBitVector extends DuckDBVector<DuckDBBitValue> {
+  private readonly dataView: DataView;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  private readonly itemOffset: number;
+  private readonly _itemCount: number;
+  private readonly itemCache: (DuckDBBitValue | 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
+  ): DuckDBBitVector {
+    const data = vectorData(vector, itemCount * 16);
+    const dataView = new DataView(
+      data.buffer,
+      data.byteOffset,
+      data.byteLength
+    );
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBBitVector(dataView, validity, vector, 0, itemCount);
+  }
+  public override get type(): DuckDBBitType {
+    return DuckDBBitType.instance;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(itemIndex: number): DuckDBBitValue | null {
+    if (!this.validity.itemValid(itemIndex)) {
+      return null;
+    }
+    // getBuffer rather than getStringBytes: the latter returns a view into the
+    // vector's memory for payloads of twelve bytes or fewer, and the value it is
+    // handed to keeps that reference, so it would dangle once the vector goes.
+    const bytes = getBuffer(this.dataView, itemIndex * 16);
+    return bytes ? new DuckDBBitValue(bytes) : null;
+  }
+  public override setItem(itemIndex: number, value: DuckDBBitValue | 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,
+            cachedItem.data
+          );
+        }
+        this.itemCacheDirty[itemIndex] = false;
+      }
+    }
+    this.validity.flush(this.vector);
+  }
+  public override slice(offset: number, length: number): DuckDBBitVector {
+    return new DuckDBBitVector(
+      new DataView(
+        this.dataView.buffer,
+        this.dataView.byteOffset + offset * 16,
+        length * 16
+      ),
+      this.validity.slice(offset, length),
+      this.vector,
+      offset,
+      length
+    );
+  }
+}

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

@@ -0,0 +1,112 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBBlobType,
+} from '../DuckDBType';
+import {
+  DuckDBBlobValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  getBuffer,
+  getStringBytes,
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBBlobVector extends DuckDBVector<DuckDBBlobValue> {
+  private readonly dataView: DataView;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  private readonly itemOffset: number;
+  private readonly _itemCount: number;
+  private readonly itemCache: (DuckDBBlobValue | 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
+  ): DuckDBBlobVector {
+    const data = vectorData(vector, itemCount * 16);
+    const dataView = new DataView(
+      data.buffer,
+      data.byteOffset,
+      data.byteLength
+    );
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBBlobVector(dataView, validity, vector, 0, itemCount);
+  }
+  public override get type(): DuckDBBlobType {
+    return DuckDBBlobType.instance;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(itemIndex: number): DuckDBBlobValue | null {
+    return this.validity.itemValid(itemIndex)
+      ? new DuckDBBlobValue(getBuffer(this.dataView, itemIndex * 16))
+      : null;
+  }
+  /**
+   * Returns the raw bytes for the item at `itemIndex`, or null if the item
+   * is SQL NULL. Avoids the `Buffer.from(...)` copy that `getItem` does.
+   *
+   * The returned `Uint8Array` is a view over the underlying string_t
+   * backing buffer for inline payloads (≤12 bytes); for larger payloads
+   * it's a fresh allocation returned by the native bindings. Treat the
+   * result as read-only either way.
+   */
+  public getItemBytes(itemIndex: number): Uint8Array | null {
+    return this.validity.itemValid(itemIndex)
+      ? getStringBytes(this.dataView, itemIndex * 16)
+      : null;
+  }
+  public override setItem(itemIndex: number, value: DuckDBBlobValue | 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,
+            cachedItem.bytes
+          );
+        }
+        this.itemCacheDirty[itemIndex] = false;
+      }
+    }
+    this.validity.flush(this.vector);
+  }
+  public override slice(offset: number, length: number): DuckDBBlobVector {
+    return new DuckDBBlobVector(
+      new DataView(
+        this.dataView.buffer,
+        this.dataView.byteOffset + offset * 16,
+        length * 16
+      ),
+      this.validity.slice(offset, length),
+      this.vector,
+      offset,
+      length
+    );
+  }
+}

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

@@ -0,0 +1,84 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBBooleanType,
+} from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  getBoolean,
+  setBoolean,
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBBooleanVector extends DuckDBVector<boolean> {
+  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
+  ): DuckDBBooleanVector {
+    const data = vectorData(vector, itemCount * duckdb.sizeof_bool);
+    const dataView = new DataView(
+      data.buffer,
+      data.byteOffset,
+      data.byteLength
+    );
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBBooleanVector(dataView, validity, vector, itemCount);
+  }
+  public override get type(): DuckDBBooleanType {
+    return DuckDBBooleanType.instance;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(itemIndex: number): boolean | null {
+    return this.validity.itemValid(itemIndex)
+      ? getBoolean(this.dataView, itemIndex * duckdb.sizeof_bool)
+      : null;
+  }
+  public override setItem(itemIndex: number, value: boolean | null) {
+    if (value != null) {
+      setBoolean(this.dataView, itemIndex * duckdb.sizeof_bool, value);
+      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): DuckDBBooleanVector {
+    return new DuckDBBooleanVector(
+      new DataView(
+        this.dataView.buffer,
+        this.dataView.byteOffset + offset * duckdb.sizeof_bool,
+        length * duckdb.sizeof_bool
+      ),
+      this.validity.slice(offset, length),
+      this.vector,
+      length
+    );
+  }
+}

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

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

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

@@ -0,0 +1,107 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBDecimalType,
+} from '../DuckDBType';
+import {
+  DuckDBDecimalValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  getDecimal128,
+  getInt128,
+  setInt128,
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBDecimal128Vector extends DuckDBVector<DuckDBDecimalValue> {
+  private readonly decimalType: DuckDBDecimalType;
+  private readonly dataView: DataView;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  private readonly _itemCount: number;
+  constructor(
+    decimalType: DuckDBDecimalType,
+    dataView: DataView,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector,
+    itemCount: number
+  ) {
+    super();
+    this.decimalType = decimalType;
+    this.dataView = dataView;
+    this.validity = validity;
+    this.vector = vector;
+    this._itemCount = itemCount;
+  }
+  static fromRawVector(
+    decimalType: DuckDBDecimalType,
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBDecimal128Vector {
+    const data = vectorData(vector, itemCount * 16);
+    const dataView = new DataView(
+      data.buffer,
+      data.byteOffset,
+      data.byteLength
+    );
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBDecimal128Vector(
+      decimalType,
+      dataView,
+      validity,
+      vector,
+      itemCount
+    );
+  }
+  public override get type(): DuckDBDecimalType {
+    return this.decimalType;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(itemIndex: number): DuckDBDecimalValue | null {
+    return this.validity.itemValid(itemIndex)
+      ? getDecimal128(this.dataView, itemIndex * 16, this.decimalType)
+      : null;
+  }
+  public getScaledValue(itemIndex: number): bigint | null {
+    return this.validity.itemValid(itemIndex)
+      ? getInt128(this.dataView, itemIndex * 16)
+      : null;
+  }
+  public override setItem(itemIndex: number, value: DuckDBDecimalValue | null) {
+    if (value != null) {
+      setInt128(this.dataView, itemIndex * 16, value.value);
+      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
+  ): DuckDBDecimal128Vector {
+    return new DuckDBDecimal128Vector(
+      this.decimalType,
+      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/DuckDBDecimal16Vector.ts

@@ -0,0 +1,104 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBDecimalType,
+} from '../DuckDBType';
+import {
+  DuckDBDecimalValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  getDecimal16,
+  getInt16,
+  setInt16,
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBDecimal16Vector extends DuckDBVector<DuckDBDecimalValue> {
+  private readonly decimalType: DuckDBDecimalType;
+  private readonly dataView: DataView;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  private readonly _itemCount: number;
+  constructor(
+    decimalType: DuckDBDecimalType,
+    dataView: DataView,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector,
+    itemCount: number
+  ) {
+    super();
+    this.decimalType = decimalType;
+    this.dataView = dataView;
+    this.validity = validity;
+    this.vector = vector;
+    this._itemCount = itemCount;
+  }
+  static fromRawVector(
+    decimalType: DuckDBDecimalType,
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBDecimal16Vector {
+    const data = vectorData(vector, itemCount * 2);
+    const dataView = new DataView(
+      data.buffer,
+      data.byteOffset,
+      data.byteLength
+    );
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBDecimal16Vector(
+      decimalType,
+      dataView,
+      validity,
+      vector,
+      itemCount
+    );
+  }
+  public override get type(): DuckDBDecimalType {
+    return this.decimalType;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(itemIndex: number): DuckDBDecimalValue | null {
+    return this.validity.itemValid(itemIndex)
+      ? getDecimal16(this.dataView, itemIndex * 2, this.decimalType)
+      : null;
+  }
+  public getScaledValue(itemIndex: number): number | null {
+    return this.validity.itemValid(itemIndex)
+      ? getInt16(this.dataView, itemIndex * 2)
+      : null;
+  }
+  public override setItem(itemIndex: number, value: DuckDBDecimalValue | null) {
+    if (value != null) {
+      setInt16(this.dataView, itemIndex * 2, Number(value.value));
+      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): DuckDBDecimal16Vector {
+    return new DuckDBDecimal16Vector(
+      this.decimalType,
+      new DataView(
+        this.dataView.buffer,
+        this.dataView.byteOffset + offset * 2,
+        length * 2
+      ),
+      this.validity.slice(offset, length),
+      this.vector,
+      length
+    );
+  }
+}

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

@@ -0,0 +1,104 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBDecimalType,
+} from '../DuckDBType';
+import {
+  DuckDBDecimalValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  getDecimal32,
+  getInt32,
+  setInt32,
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBDecimal32Vector extends DuckDBVector<DuckDBDecimalValue> {
+  private readonly decimalType: DuckDBDecimalType;
+  private readonly dataView: DataView;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  private readonly _itemCount: number;
+  constructor(
+    decimalType: DuckDBDecimalType,
+    dataView: DataView,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector,
+    itemCount: number
+  ) {
+    super();
+    this.decimalType = decimalType;
+    this.dataView = dataView;
+    this.validity = validity;
+    this.vector = vector;
+    this._itemCount = itemCount;
+  }
+  static fromRawVector(
+    decimalType: DuckDBDecimalType,
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBDecimal32Vector {
+    const data = vectorData(vector, itemCount * 4);
+    const dataView = new DataView(
+      data.buffer,
+      data.byteOffset,
+      data.byteLength
+    );
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBDecimal32Vector(
+      decimalType,
+      dataView,
+      validity,
+      vector,
+      itemCount
+    );
+  }
+  public override get type(): DuckDBDecimalType {
+    return this.decimalType;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(itemIndex: number): DuckDBDecimalValue | null {
+    return this.validity.itemValid(itemIndex)
+      ? getDecimal32(this.dataView, itemIndex * 4, this.decimalType)
+      : null;
+  }
+  public getScaledValue(itemIndex: number): number | null {
+    return this.validity.itemValid(itemIndex)
+      ? getInt32(this.dataView, itemIndex * 4)
+      : null;
+  }
+  public override setItem(itemIndex: number, value: DuckDBDecimalValue | null) {
+    if (value != null) {
+      setInt32(this.dataView, itemIndex * 4, Number(value.value));
+      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): DuckDBDecimal32Vector {
+    return new DuckDBDecimal32Vector(
+      this.decimalType,
+      new DataView(
+        this.dataView.buffer,
+        this.dataView.byteOffset + offset * 4,
+        length * 4
+      ),
+      this.validity.slice(offset, length),
+      this.vector,
+      length
+    );
+  }
+}