@avidian/duckdb-bun 0.0.0-stage → 1.0.1

package/vendor/node-api/src/vectors/DuckDBDecimal64Vector.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 {
+  getDecimal64,
+  getInt64,
+  setInt64,
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBDecimal64Vector 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
+  ): DuckDBDecimal64Vector {
+    const data = vectorData(vector, itemCount * 8);
+    const dataView = new DataView(
+      data.buffer,
+      data.byteOffset,
+      data.byteLength
+    );
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBDecimal64Vector(
+      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)
+      ? getDecimal64(this.dataView, itemIndex * 8, this.decimalType)
+      : null;
+  }
+  public getScaledValue(itemIndex: number): bigint | null {
+    return this.validity.itemValid(itemIndex)
+      ? getInt64(this.dataView, itemIndex * 8)
+      : null;
+  }
+  public override setItem(itemIndex: number, value: DuckDBDecimalValue | null) {
+    if (value != null) {
+      setInt64(this.dataView, itemIndex * 8, 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): DuckDBDecimal64Vector {
+    return new DuckDBDecimal64Vector(
+      this.decimalType,
+      new DataView(
+        this.dataView.buffer,
+        this.dataView.byteOffset + offset * 8,
+        length * 8
+      ),
+      this.validity.slice(offset, length),
+      this.vector,
+      length
+    );
+  }
+}

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

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

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

@@ -0,0 +1,75 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBEnumType,
+} from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBEnum16Vector extends DuckDBVector<string> {
+  private readonly enumType: DuckDBEnumType;
+  private readonly items: Uint16Array;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  constructor(
+    enumType: DuckDBEnumType,
+    items: Uint16Array,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector
+  ) {
+    super();
+    this.enumType = enumType;
+    this.items = items;
+    this.validity = validity;
+    this.vector = vector;
+  }
+  static fromRawVector(
+    enumType: DuckDBEnumType,
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBEnum16Vector {
+    const data = vectorData(vector, itemCount * 2);
+    const items = new Uint16Array(data.buffer, data.byteOffset, itemCount);
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBEnum16Vector(enumType, items, validity, vector);
+  }
+  public override get type(): DuckDBEnumType {
+    return this.enumType;
+  }
+  public override get itemCount(): number {
+    return this.items.length;
+  }
+  public override getItem(itemIndex: number): string | null {
+    return this.validity.itemValid(itemIndex)
+      ? this.enumType.values[this.items[itemIndex]]
+      : null;
+  }
+  public override setItem(itemIndex: number, value: string | null) {
+    if (value != null) {
+      this.items[itemIndex] = this.enumType.indexForValue(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): DuckDBEnum16Vector {
+    return new DuckDBEnum16Vector(
+      this.enumType,
+      this.items.slice(offset, offset + length),
+      this.validity.slice(offset, length),
+      this.vector
+    );
+  }
+}

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

@@ -0,0 +1,75 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBEnumType,
+} from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBEnum32Vector extends DuckDBVector<string> {
+  private readonly enumType: DuckDBEnumType;
+  private readonly items: Uint32Array;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  constructor(
+    enumType: DuckDBEnumType,
+    items: Uint32Array,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector
+  ) {
+    super();
+    this.enumType = enumType;
+    this.items = items;
+    this.validity = validity;
+    this.vector = vector;
+  }
+  static fromRawVector(
+    enumType: DuckDBEnumType,
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBEnum32Vector {
+    const data = vectorData(vector, itemCount * 4);
+    const items = new Uint32Array(data.buffer, data.byteOffset, itemCount);
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBEnum32Vector(enumType, items, validity, vector);
+  }
+  public override get type(): DuckDBEnumType {
+    return this.enumType;
+  }
+  public override get itemCount(): number {
+    return this.items.length;
+  }
+  public override getItem(itemIndex: number): string | null {
+    return this.validity.itemValid(itemIndex)
+      ? this.enumType.values[this.items[itemIndex]]
+      : null;
+  }
+  public override setItem(itemIndex: number, value: string | null) {
+    if (value != null) {
+      this.items[itemIndex] = this.enumType.indexForValue(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): DuckDBEnum32Vector {
+    return new DuckDBEnum32Vector(
+      this.enumType,
+      this.items.slice(offset, offset + length),
+      this.validity.slice(offset, length),
+      this.vector
+    );
+  }
+}

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

@@ -0,0 +1,75 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBEnumType,
+} from '../DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBEnum8Vector extends DuckDBVector<string> {
+  private readonly enumType: DuckDBEnumType;
+  private readonly items: Uint8Array;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  constructor(
+    enumType: DuckDBEnumType,
+    items: Uint8Array,
+    validity: DuckDBValidity,
+    vector: duckdb.Vector
+  ) {
+    super();
+    this.enumType = enumType;
+    this.items = items;
+    this.validity = validity;
+    this.vector = vector;
+  }
+  static fromRawVector(
+    enumType: DuckDBEnumType,
+    vector: duckdb.Vector,
+    itemCount: number
+  ): DuckDBEnum8Vector {
+    const data = vectorData(vector, itemCount);
+    const items = new Uint8Array(data.buffer, data.byteOffset, itemCount);
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBEnum8Vector(enumType, items, validity, vector);
+  }
+  public override get type(): DuckDBEnumType {
+    return this.enumType;
+  }
+  public override get itemCount(): number {
+    return this.items.length;
+  }
+  public override getItem(itemIndex: number): string | null {
+    return this.validity.itemValid(itemIndex)
+      ? this.enumType.values[this.items[itemIndex]]
+      : null;
+  }
+  public override setItem(itemIndex: number, value: string | null) {
+    if (value != null) {
+      this.items[itemIndex] = this.enumType.indexForValue(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): DuckDBEnum8Vector {
+    return new DuckDBEnum8Vector(
+      this.enumType,
+      this.items.slice(offset, offset + length),
+      this.validity.slice(offset, length),
+      this.vector
+    );
+  }
+}

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

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

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

@@ -0,0 +1,97 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import {
+  DuckDBGeometryType,
+} from '../DuckDBType';
+import {
+  DuckDBGeometryValue,
+} from '../values';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBValidity } from './DuckDBValidity';
+import {
+  getBuffer,
+  vectorData,
+} from './dataAccessors';
+
+export class DuckDBGeometryVector extends DuckDBVector<DuckDBGeometryValue> {
+  private readonly dataView: DataView;
+  private readonly validity: DuckDBValidity;
+  private readonly vector: duckdb.Vector;
+  private readonly itemOffset: number;
+  private readonly _itemCount: number;
+  private readonly itemCache: (DuckDBGeometryValue | 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
+  ): DuckDBGeometryVector {
+    const data = vectorData(vector, itemCount * 16);
+    const dataView = new DataView(
+      data.buffer,
+      data.byteOffset,
+      data.byteLength
+    );
+    const validity = DuckDBValidity.fromVector(vector, itemCount);
+    return new DuckDBGeometryVector(dataView, validity, vector, 0, itemCount);
+  }
+  public override get type(): DuckDBGeometryType {
+    return DuckDBGeometryType.instance;
+  }
+  public override get itemCount(): number {
+    return this._itemCount;
+  }
+  public override getItem(itemIndex: number): DuckDBGeometryValue | null {
+    return this.validity.itemValid(itemIndex)
+      ? new DuckDBGeometryValue(getBuffer(this.dataView, itemIndex * 16))
+      : null;
+  }
+  public override setItem(itemIndex: number, value: DuckDBGeometryValue | 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): DuckDBGeometryVector {
+    return new DuckDBGeometryVector(
+      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/DuckDBHugeIntVector.ts

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