@avidian/duckdb-bun 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,138 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBStructType,
+} from '../DuckDBType';
+import {
+  DuckDBStructValue,
+  DuckDBValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+
+export class DuckDBStructVector extends DuckDBVector<DuckDBStructValue> {
+  private readonly structType: DuckDBStructType;
+  private readonly _itemCount: number;
+  private readonly entryVectors: readonly DuckDBVector[];
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  constructor(
+    structType: DuckDBStructType,
+    itemCount: number,
+    entryVectors: readonly DuckDBVector[],
+    validity: DuckDBValidity,
+    vector: duckdb.Vector
+  ) {
+    super();
+    this.structType = structType;
+    this._itemCount = itemCount;
+    this.entryVectors = entryVectors;
+    this.validity = validity;
+    this.vector = vector;
+  }
+  static fromRawVector(
+    structType: DuckDBStructType,
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBStructVector {
+    const entryCount = structType.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, structType.entryTypes[i])
+      );
+    }
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBStructVector(
+      structType,
+      itemCount,
+      entryVectors,
+      validity,
+      vector
+    );
+  }
+  public override get type(): DuckDBStructType {
+    return this.structType;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(itemIndex: number): DuckDBStructValue | null {
+    if (!this.validity.itemValid(itemIndex)) {
+      return null;
+    }
+    const entries: { [name: string]: DuckDBValue } = {};
+    const entryCount = this.structType.entryCount;
+    for (let i = 0; i < entryCount; i++) {
+      entries[this.structType.entryNames[i]] =
+        this.entryVectors[i].getItem(itemIndex);
+    }
+    return new DuckDBStructValue(entries);
+  }
+  public getItemValue(
+    itemIndex: number,
+    entryIndex: number
+  ): DuckDBValue | null {
+    if (!this.validity.itemValid(itemIndex)) {
+      return null;
+    }
+    return this.entryVectors[entryIndex].getItem(itemIndex);
+  }
+  /**
+   * Returns the underlying child vector for entry `index`. Useful for
+   * callers that want direct access to a child's flat backing storage
+   * (e.g. when decoding a physical-layout type that overlays a STRUCT).
+   */
+  public entryVectorAt(index: number): DuckDBVector {
+    return this.entryVectors[index];
+  }
+  /**
+   * Returns whether the top-level row at `itemIndex` is non-NULL. Useful
+   * for callers overlaying a logical type on a STRUCT vector that need to
+   * distinguish a SQL-NULL row from a row whose children just happen to
+   * be NULL.
+   */
+  public isItemValid(itemIndex: number): boolean {
+    return this.validity.itemValid(itemIndex);
+  }
+  public override setItem(itemIndex: number, value: DuckDBStructValue | null) {
+    if (value != null) {
+      const entryCount = this.structType.entryCount;
+      for (let i = 0; i < entryCount; i++) {
+        this.entryVectors[i].setItem(
+          itemIndex,
+          value.entries[this.structType.entryNames[i]]
+        );
+      }
+      this.validity.setItemValid(itemIndex, true);
+    } else {
+      const entryCount = this.structType.entryCount;
+      for (let i = 0; i < entryCount; i++) {
+        this.entryVectors[i].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): DuckDBStructVector {
+    return new DuckDBStructVector(
+      this.structType,
+      length,
+      this.entryVectors.map((entryVector) => entryVector.slice(offset, length)),
+      this.validity.slice(offset, length),
+      this.vector
+    );
+  }
+}

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

@@ -0,0 +1,80 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBTimeNSType,
+} from '../DuckDBType';
+import {
+  DuckDBTimeNSValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBTimeNSVector extends DuckDBVector<DuckDBTimeNSValue> {
+  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
+  ): DuckDBTimeNSVector {
+    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 DuckDBTimeNSVector(items, validity, vector);
+  }
+  public override get type(): DuckDBTimeNSType {
+    return DuckDBTimeNSType.instance;
+  }
+  public override get itemCount(): number {
+    return this.items.length;
+  }
+  public override getItem(itemIndex: number): DuckDBTimeNSValue | null {
+    return this.validity.itemValid(itemIndex)
+      ? new DuckDBTimeNSValue(this.items[itemIndex])
+      : null;
+  }
+  public override setItem(itemIndex: number, value: DuckDBTimeNSValue | 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): DuckDBTimeNSVector {
+    return new DuckDBTimeNSVector(
+      this.items.slice(offset, offset + length),
+      this.validity.slice(offset, length),
+      this.vector
+    );
+  }
+}

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

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

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

@@ -0,0 +1,80 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBTimeType,
+} from '../DuckDBType';
+import {
+  DuckDBTimeValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBTimeVector extends DuckDBVector<DuckDBTimeValue> {
+  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
+  ): DuckDBTimeVector {
+    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 DuckDBTimeVector(items, validity, vector);
+  }
+  public override get type(): DuckDBTimeType {
+    return DuckDBTimeType.instance;
+  }
+  public override get itemCount(): number {
+    return this.items.length;
+  }
+  public override getItem(itemIndex: number): DuckDBTimeValue | null {
+    return this.validity.itemValid(itemIndex)
+      ? new DuckDBTimeValue(this.items[itemIndex])
+      : null;
+  }
+  public override setItem(itemIndex: number, value: DuckDBTimeValue | 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): DuckDBTimeVector {
+    return new DuckDBTimeVector(
+      this.items.slice(offset, offset + length),
+      this.validity.slice(offset, length),
+      this.vector
+    );
+  }
+}

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

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

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

@@ -0,0 +1,88 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBTimestampNanosecondsType,
+} from '../DuckDBType';
+import {
+  DuckDBTimestampNanosecondsValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBTimestampNanosecondsVector extends DuckDBVector<DuckDBTimestampNanosecondsValue> {
+  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
+  ): DuckDBTimestampNanosecondsVector {
+    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 DuckDBTimestampNanosecondsVector(items, validity, vector);
+  }
+  public override get type(): DuckDBTimestampNanosecondsType {
+    return DuckDBTimestampNanosecondsType.instance;
+  }
+  public override get itemCount(): number {
+    return this.items.length;
+  }
+  public override getItem(
+    itemIndex: number
+  ): DuckDBTimestampNanosecondsValue | null {
+    return this.validity.itemValid(itemIndex)
+      ? new DuckDBTimestampNanosecondsValue(this.items[itemIndex])
+      : null;
+  }
+  public override setItem(
+    itemIndex: number,
+    value: DuckDBTimestampNanosecondsValue | 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
+  ): DuckDBTimestampNanosecondsVector {
+    return new DuckDBTimestampNanosecondsVector(
+      this.items.slice(offset, offset + length),
+      this.validity.slice(offset, length),
+      this.vector
+    );
+  }
+}

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

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