@avidian/duckdb-bun 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,88 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBTimestampTZNanosecondsType,
+} from '../DuckDBType';
+import {
+  DuckDBTimestampTZNanosecondsValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBTimestampTZNanosecondsVector extends DuckDBVector<DuckDBTimestampTZNanosecondsValue> {
+  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
+  ): DuckDBTimestampTZNanosecondsVector {
+    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 DuckDBTimestampTZNanosecondsVector(items, validity, vector);
+  }
+  public override get type(): DuckDBTimestampTZNanosecondsType {
+    return DuckDBTimestampTZNanosecondsType.instance;
+  }
+  public override get itemCount(): number {
+    return this.items.length;
+  }
+  public override getItem(
+    itemIndex: number
+  ): DuckDBTimestampTZNanosecondsValue | null {
+    return this.validity.itemValid(itemIndex)
+      ? new DuckDBTimestampTZNanosecondsValue(this.items[itemIndex])
+      : null;
+  }
+  public override setItem(
+    itemIndex: number,
+    value: DuckDBTimestampTZNanosecondsValue | null
+  ) {
+    if (value != null) {
+      // Checked inline for bulk-write throughput; see dataAccessors.ts.
+      if (BigInt.asIntN(64, value.nanos) !== value.nanos) {
+        throw new Error(`bigint out of int64 range`);
+      }
+      this.items[itemIndex] = value.nanos;
+      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
+  ): DuckDBTimestampTZNanosecondsVector {
+    return new DuckDBTimestampTZNanosecondsVector(
+      this.items.slice(offset, offset + length),
+      this.validity.slice(offset, length),
+      this.vector
+    );
+  }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,125 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBStructType,
+} from '../DuckDBType';
+import {
+  DuckDBTupleValue,
+  DuckDBValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+
+/**
+ * A vector of a tuple type: a STRUCT whose entry names are all empty (see
+ * `DuckDBStructType.isTuple`). Items are `DuckDBTupleValue`s.
+ */
+export class DuckDBTupleVector extends DuckDBVector<DuckDBTupleValue> {
+  private readonly tupleType: DuckDBStructType;
+  private readonly _itemCount: number;
+  private readonly entryVectors: readonly DuckDBVector[];
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  constructor(
+    tupleType: DuckDBStructType,
+    itemCount: number,
+    entryVectors: readonly DuckDBVector[],
+    validity: DuckDBValidity,
+    vector: duckdb.Vector
+  ) {
+    super();
+    this.tupleType = tupleType;
+    this._itemCount = itemCount;
+    this.entryVectors = entryVectors;
+    this.validity = validity;
+    this.vector = vector;
+  }
+  static fromRawVector(
+    tupleType: DuckDBStructType,
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBTupleVector {
+    const entryCount = tupleType.entryCount;
+    const entryVectors: DuckDBVector[] = [];
+    for (let i = 0; i < entryCount; i++) {
+      const child_vector = duckdb.struct_vector_get_child(vector, i);
+      entryVectors.push(
+        DuckDBVector.create(child_vector, itemCount, tupleType.entryTypes[i])
+      );
+    }
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBTupleVector(
+      tupleType,
+      itemCount,
+      entryVectors,
+      validity,
+      vector
+    );
+  }
+  public override get type(): DuckDBStructType {
+    return this.tupleType;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(itemIndex: number): DuckDBTupleValue | null {
+    if (!this.validity.itemValid(itemIndex)) {
+      return null;
+    }
+    return new DuckDBTupleValue(
+      this.entryVectors.map((entryVector) => entryVector.getItem(itemIndex))
+    );
+  }
+  public getItemValue(
+    itemIndex: number,
+    entryIndex: number
+  ): DuckDBValue | null {
+    if (!this.validity.itemValid(itemIndex)) {
+      return null;
+    }
+    return this.entryVectors[entryIndex].getItem(itemIndex);
+  }
+  public override setItem(itemIndex: number, value: DuckDBTupleValue | null) {
+    if (value != null) {
+      if (!(value instanceof DuckDBTupleValue)) {
+        throw new Error(`Expected DuckDBTupleValue for ${this.tupleType}`);
+      }
+      const entryCount = this.tupleType.entryCount;
+      if (value.items.length !== entryCount) {
+        throw new Error(
+          `Expected ${entryCount} items for ${this.tupleType}, got ${value.items.length}`
+        );
+      }
+      for (let i = 0; i < entryCount; i++) {
+        this.entryVectors[i].setItem(itemIndex, value.items[i]);
+      }
+      this.validity.setItemValid(itemIndex, true);
+    } else {
+      for (const entryVector of this.entryVectors) {
+        entryVector.setItem(itemIndex, null);
+      }
+      this.validity.setItemValid(itemIndex, false);
+    }
+  }
+  public setItemValue(
+    itemIndex: number,
+    entryIndex: number,
+    value: DuckDBValue
+  ) {
+    return this.entryVectors[entryIndex].setItem(itemIndex, value);
+  }
+  public override flush() {
+    for (const entryVector of this.entryVectors) {
+      entryVector.flush();
+    }
+    this.validity.flush(this.vector);
+  }
+  public override slice(offset: number, length: number): DuckDBTupleVector {
+    return new DuckDBTupleVector(
+      this.tupleType,
+      length,
+      this.entryVectors.map((entryVector) => entryVector.slice(offset, length)),
+      this.validity.slice(offset, length),
+      this.vector
+    );
+  }
+}

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

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

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

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

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