@avidian/duckdb-bun 0.0.0-stage → 1.0.0

package/vendor/node-api/src/DuckDBLogicalType.ts

@@ -0,0 +1,446 @@
+import duckdb from "../../../src/bindings/index.ts";
+import {
+  DuckDBAnyType,
+  DuckDBArrayType,
+  DuckDBBigIntType,
+  DuckDBBigNumType,
+  DuckDBBitType,
+  DuckDBBlobType,
+  DuckDBBooleanType,
+  DuckDBDateType,
+  DuckDBDecimalType,
+  DuckDBDoubleType,
+  DuckDBEnumType,
+  DuckDBFloatType,
+  DuckDBGeometryType,
+  DuckDBHugeIntType,
+  DuckDBIntegerLiteralType,
+  DuckDBIntegerType,
+  DuckDBIntervalType,
+  DuckDBListType,
+  DuckDBMapType,
+  DuckDBSQLNullType,
+  DuckDBSmallIntType,
+  DuckDBStringLiteralType,
+  DuckDBStructType,
+  DuckDBTimeNSType,
+  DuckDBTimeTZType,
+  DuckDBTimeType,
+  DuckDBTimestampMillisecondsType,
+  DuckDBTimestampNanosecondsType,
+  DuckDBTimestampSecondsType,
+  DuckDBTimestampTZType,
+  DuckDBTimestampTZNanosecondsType,
+  DuckDBTimestampType,
+  DuckDBTinyIntType,
+  DuckDBType,
+  DuckDBUBigIntType,
+  DuckDBUHugeIntType,
+  DuckDBUIntegerType,
+  DuckDBUSmallIntType,
+  DuckDBUTinyIntType,
+  DuckDBUUIDType,
+  DuckDBUnionType,
+  DuckDBVarCharType,
+  DuckDBVariantType,
+} from './DuckDBType';
+import { DuckDBTypeId } from './DuckDBTypeId';
+
+export class DuckDBLogicalType {
+  readonly logical_type: duckdb.LogicalType;
+  protected constructor(logical_type: duckdb.LogicalType) {
+    this.logical_type = logical_type;
+  }
+  static create(logical_type: duckdb.LogicalType): DuckDBLogicalType {
+    switch (duckdb.get_type_id(logical_type)) {
+      case duckdb.Type.DECIMAL:
+        return new DuckDBDecimalLogicalType(logical_type);
+      case duckdb.Type.ENUM:
+        return new DuckDBEnumLogicalType(logical_type);
+      case duckdb.Type.LIST:
+        return new DuckDBListLogicalType(logical_type);
+      case duckdb.Type.STRUCT:
+        return new DuckDBStructLogicalType(logical_type);
+      case duckdb.Type.MAP:
+        return new DuckDBMapLogicalType(logical_type);
+      case duckdb.Type.ARRAY:
+        return new DuckDBArrayLogicalType(logical_type);
+      case duckdb.Type.UNION:
+        return new DuckDBUnionLogicalType(logical_type);
+      case duckdb.Type.GEOMETRY:
+        return new DuckDBGeometryLogicalType(logical_type);
+      default:
+        return new DuckDBLogicalType(logical_type);
+    }
+  }
+  public static createDecimal(
+    width: number,
+    scale: number
+  ): DuckDBDecimalLogicalType {
+    return new DuckDBDecimalLogicalType(
+      duckdb.create_decimal_type(width, scale)
+    );
+  }
+  public static createEnum(
+    member_names: readonly string[]
+  ): DuckDBEnumLogicalType {
+    return new DuckDBEnumLogicalType(duckdb.create_enum_type(member_names));
+  }
+  public static createList(
+    valueType: DuckDBLogicalType
+  ): DuckDBListLogicalType {
+    return new DuckDBListLogicalType(
+      duckdb.create_list_type(valueType.logical_type)
+    );
+  }
+  public static createStruct(
+    entryNames: readonly string[],
+    entryLogicalTypes: readonly DuckDBLogicalType[]
+  ): DuckDBStructLogicalType {
+    const length = entryNames.length;
+    if (length !== entryLogicalTypes.length) {
+      throw new Error(`Could not create struct: \
+        entryNames length (${entryNames.length}) does not match entryLogicalTypes length (${entryLogicalTypes.length})`);
+    }
+    const member_types: duckdb.LogicalType[] = [];
+    const member_names: string[] = [];
+    for (let i = 0; i < length; i++) {
+      member_types.push(entryLogicalTypes[i].logical_type);
+      member_names.push(entryNames[i]);
+    }
+    return new DuckDBStructLogicalType(
+      duckdb.create_struct_type(member_types, member_names)
+    );
+  }
+  public static createMap(
+    keyType: DuckDBLogicalType,
+    valueType: DuckDBLogicalType
+  ): DuckDBMapLogicalType {
+    return new DuckDBMapLogicalType(
+      duckdb.create_map_type(keyType.logical_type, valueType.logical_type)
+    );
+  }
+  public static createArray(
+    valueType: DuckDBLogicalType,
+    length: number
+  ): DuckDBArrayLogicalType {
+    return new DuckDBArrayLogicalType(
+      duckdb.create_array_type(valueType.logical_type, length)
+    );
+  }
+  public static createUnion(
+    memberTags: readonly string[],
+    memberLogicalTypes: readonly DuckDBLogicalType[]
+  ): DuckDBUnionLogicalType {
+    const length = memberTags.length;
+    if (length !== memberLogicalTypes.length) {
+      throw new Error(`Could not create union: \
+        memberTags length (${memberTags.length}) does not match memberLogicalTypes length (${memberLogicalTypes.length})`);
+    }
+    const member_types: duckdb.LogicalType[] = [];
+    const member_names: string[] = [];
+    for (let i = 0; i < length; i++) {
+      member_types.push(memberLogicalTypes[i].logical_type);
+      member_names.push(memberTags[i]);
+    }
+    return new DuckDBUnionLogicalType(
+      duckdb.create_union_type(member_types, member_names)
+    );
+  }
+  public get typeId(): DuckDBTypeId {
+    return duckdb.get_type_id(this.logical_type) as number as DuckDBTypeId;
+  }
+  public get alias(): string | undefined {
+    return duckdb.logical_type_get_alias(this.logical_type) || undefined;
+  }
+  public set alias(newAlias: string | null | undefined) {
+    duckdb.logical_type_set_alias(this.logical_type, newAlias || '');
+  }
+  public asType(): DuckDBType {
+    const alias = this.alias;
+    switch (this.typeId) {
+      case DuckDBTypeId.BOOLEAN:
+        return DuckDBBooleanType.create(alias);
+      case DuckDBTypeId.TINYINT:
+        return DuckDBTinyIntType.create(alias);
+      case DuckDBTypeId.SMALLINT:
+        return DuckDBSmallIntType.create(alias);
+      case DuckDBTypeId.INTEGER:
+        return DuckDBIntegerType.create(alias);
+      case DuckDBTypeId.BIGINT:
+        return DuckDBBigIntType.create(alias);
+      case DuckDBTypeId.UTINYINT:
+        return DuckDBUTinyIntType.create(alias);
+      case DuckDBTypeId.USMALLINT:
+        return DuckDBUSmallIntType.create(alias);
+      case DuckDBTypeId.UINTEGER:
+        return DuckDBUIntegerType.create(alias);
+      case DuckDBTypeId.UBIGINT:
+        return DuckDBUBigIntType.create(alias);
+      case DuckDBTypeId.FLOAT:
+        return DuckDBFloatType.create(alias);
+      case DuckDBTypeId.DOUBLE:
+        return DuckDBDoubleType.create(alias);
+      case DuckDBTypeId.TIMESTAMP:
+        return DuckDBTimestampType.create(alias);
+      case DuckDBTypeId.DATE:
+        return DuckDBDateType.create(alias);
+      case DuckDBTypeId.TIME:
+        return DuckDBTimeType.create(alias);
+      case DuckDBTypeId.INTERVAL:
+        return DuckDBIntervalType.create(alias);
+      case DuckDBTypeId.HUGEINT:
+        return DuckDBHugeIntType.create(alias);
+      case DuckDBTypeId.UHUGEINT:
+        return DuckDBUHugeIntType.create(alias);
+      case DuckDBTypeId.VARCHAR:
+        return DuckDBVarCharType.create(alias);
+      case DuckDBTypeId.BLOB:
+        return DuckDBBlobType.create(alias);
+      case DuckDBTypeId.DECIMAL:
+        throw new Error('Expected override');
+      case DuckDBTypeId.TIMESTAMP_S:
+        return DuckDBTimestampSecondsType.create(alias);
+      case DuckDBTypeId.TIMESTAMP_MS:
+        return DuckDBTimestampMillisecondsType.create(alias);
+      case DuckDBTypeId.TIMESTAMP_NS:
+        return DuckDBTimestampNanosecondsType.create(alias);
+      case DuckDBTypeId.ENUM:
+        throw new Error('Expected override');
+      case DuckDBTypeId.LIST:
+        throw new Error('Expected override');
+      case DuckDBTypeId.STRUCT:
+        throw new Error('Expected override');
+      case DuckDBTypeId.MAP:
+        throw new Error('Expected override');
+      case DuckDBTypeId.ARRAY:
+        throw new Error('Expected override');
+      case DuckDBTypeId.UUID:
+        return DuckDBUUIDType.create(alias);
+      case DuckDBTypeId.UNION:
+        throw new Error('Expected override');
+      case DuckDBTypeId.BIT:
+        return DuckDBBitType.create(alias);
+      case DuckDBTypeId.TIME_TZ:
+        return DuckDBTimeTZType.create(alias);
+      case DuckDBTypeId.TIMESTAMP_TZ:
+        return DuckDBTimestampTZType.create(alias);
+      case DuckDBTypeId.ANY:
+        return DuckDBAnyType.create(alias);
+      case DuckDBTypeId.BIGNUM:
+        return DuckDBBigNumType.create(alias);
+      case DuckDBTypeId.SQLNULL:
+        return DuckDBSQLNullType.create(alias);
+      case DuckDBTypeId.STRING_LITERAL:
+        return DuckDBStringLiteralType.create(alias);
+      case DuckDBTypeId.INTEGER_LITERAL:
+        return DuckDBIntegerLiteralType.create(alias);
+      case DuckDBTypeId.TIME_NS:
+        return DuckDBTimeNSType.create(alias);
+      case DuckDBTypeId.GEOMETRY:
+        throw new Error('Expected override');
+      case DuckDBTypeId.VARIANT:
+        return DuckDBVariantType.create(alias);
+      case DuckDBTypeId.TIMESTAMP_TZ_NS:
+        return DuckDBTimestampTZNanosecondsType.create(alias);
+      default:
+        throw new Error(`Unexpected type id: ${this.typeId}`);
+    }
+  }
+}
+
+export class DuckDBDecimalLogicalType extends DuckDBLogicalType {
+  public get width(): number {
+    return duckdb.decimal_width(this.logical_type);
+  }
+  public get scale(): number {
+    return duckdb.decimal_scale(this.logical_type);
+  }
+  public get internalTypeId(): DuckDBTypeId {
+    return duckdb.decimal_internal_type(
+      this.logical_type
+    ) as number as DuckDBTypeId;
+  }
+  public override asType(): DuckDBDecimalType {
+    return new DuckDBDecimalType(this.width, this.scale, this.alias);
+  }
+}
+
+export class DuckDBEnumLogicalType extends DuckDBLogicalType {
+  public get valueCount(): number {
+    return duckdb.enum_dictionary_size(this.logical_type);
+  }
+  public value(index: number): string {
+    return duckdb.enum_dictionary_value(this.logical_type, index);
+  }
+  public values(): readonly string[] {
+    const values: string[] = [];
+    const count = this.valueCount;
+    for (let i = 0; i < count; i++) {
+      values.push(this.value(i));
+    }
+    return values;
+  }
+  public get internalTypeId(): DuckDBTypeId {
+    return duckdb.enum_internal_type(
+      this.logical_type
+    ) as number as DuckDBTypeId;
+  }
+  public override asType(): DuckDBEnumType {
+    return new DuckDBEnumType(this.values(), this.internalTypeId, this.alias);
+  }
+}
+
+export class DuckDBListLogicalType extends DuckDBLogicalType {
+  public get valueType(): DuckDBLogicalType {
+    return DuckDBLogicalType.create(
+      duckdb.list_type_child_type(this.logical_type)
+    );
+  }
+  public override asType(): DuckDBListType {
+    return new DuckDBListType(this.valueType.asType(), this.alias);
+  }
+}
+
+export class DuckDBStructLogicalType extends DuckDBLogicalType {
+  public get entryCount(): number {
+    return duckdb.struct_type_child_count(this.logical_type);
+  }
+  public entryName(index: number): string {
+    return duckdb.struct_type_child_name(this.logical_type, index);
+  }
+  public entryLogicalType(index: number): DuckDBLogicalType {
+    return DuckDBLogicalType.create(
+      duckdb.struct_type_child_type(this.logical_type, index)
+    );
+  }
+  public entryType(index: number): DuckDBType {
+    return this.entryLogicalType(index).asType();
+  }
+  public entryNames(): string[] {
+    const names: string[] = [];
+    const count = this.entryCount;
+    for (let i = 0; i < count; i++) {
+      names.push(this.entryName(i));
+    }
+    return names;
+  }
+  public entryLogicalTypes(): DuckDBLogicalType[] {
+    const valueTypes: DuckDBLogicalType[] = [];
+    const count = this.entryCount;
+    for (let i = 0; i < count; i++) {
+      valueTypes.push(this.entryLogicalType(i));
+    }
+    return valueTypes;
+  }
+  public entryTypes(): DuckDBType[] {
+    const valueTypes: DuckDBType[] = [];
+    const count = this.entryCount;
+    for (let i = 0; i < count; i++) {
+      valueTypes.push(this.entryType(i));
+    }
+    return valueTypes;
+  }
+  public override asType(): DuckDBStructType {
+    return new DuckDBStructType(
+      this.entryNames(),
+      this.entryTypes(),
+      this.alias
+    );
+  }
+}
+
+export class DuckDBMapLogicalType extends DuckDBLogicalType {
+  public get keyType(): DuckDBLogicalType {
+    return DuckDBLogicalType.create(
+      duckdb.map_type_key_type(this.logical_type)
+    );
+  }
+  public get valueType(): DuckDBLogicalType {
+    return DuckDBLogicalType.create(
+      duckdb.map_type_value_type(this.logical_type)
+    );
+  }
+  public override asType(): DuckDBMapType {
+    return new DuckDBMapType(
+      this.keyType.asType(),
+      this.valueType.asType(),
+      this.alias
+    );
+  }
+}
+
+export class DuckDBArrayLogicalType extends DuckDBLogicalType {
+  public get valueType(): DuckDBLogicalType {
+    return DuckDBLogicalType.create(
+      duckdb.array_type_child_type(this.logical_type)
+    );
+  }
+  public get length(): number {
+    return duckdb.array_type_array_size(this.logical_type);
+  }
+  public override asType(): DuckDBArrayType {
+    return new DuckDBArrayType(
+      this.valueType.asType(),
+      this.length,
+      this.alias
+    );
+  }
+}
+
+export class DuckDBUnionLogicalType extends DuckDBLogicalType {
+  public get memberCount(): number {
+    return duckdb.union_type_member_count(this.logical_type);
+  }
+  public memberTag(index: number): string {
+    return duckdb.union_type_member_name(this.logical_type, index);
+  }
+  public memberLogicalType(index: number): DuckDBLogicalType {
+    return DuckDBLogicalType.create(
+      duckdb.union_type_member_type(this.logical_type, index)
+    );
+  }
+  public memberType(index: number): DuckDBType {
+    return this.memberLogicalType(index).asType();
+  }
+  public memberTags(): string[] {
+    const tags: string[] = [];
+    const count = this.memberCount;
+    for (let i = 0; i < count; i++) {
+      tags.push(this.memberTag(i));
+    }
+    return tags;
+  }
+  public memberLogicalTypes(): DuckDBLogicalType[] {
+    const valueTypes: DuckDBLogicalType[] = [];
+    const count = this.memberCount;
+    for (let i = 0; i < count; i++) {
+      valueTypes.push(this.memberLogicalType(i));
+    }
+    return valueTypes;
+  }
+  public memberTypes(): DuckDBType[] {
+    const valueTypes: DuckDBType[] = [];
+    const count = this.memberCount;
+    for (let i = 0; i < count; i++) {
+      valueTypes.push(this.memberType(i));
+    }
+    return valueTypes;
+  }
+  public override asType(): DuckDBUnionType {
+    return new DuckDBUnionType(
+      this.memberTags(),
+      this.memberTypes(),
+      this.alias
+    );
+  }
+}
+
+export class DuckDBGeometryLogicalType extends DuckDBLogicalType {
+  public get crs(): string | undefined {
+    return duckdb.geometry_type_get_crs(this.logical_type) || undefined;
+  }
+  public override asType(): DuckDBGeometryType {
+    return DuckDBGeometryType.create(this.alias, this.crs);
+  }
+}

package/vendor/node-api/src/DuckDBMaterializedResult.ts

@@ -0,0 +1,39 @@
+import duckdb from "../../../src/bindings/index.ts";
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBResult } from './DuckDBResult';
+import { StatementType } from './enums';
+
+export class DuckDBMaterializedResult extends DuckDBResult {
+  private closedCounts: { rowCount: number; chunkCount: number } | undefined;
+  constructor(result: duckdb.Result, preparedStatementType?: StatementType) {
+    super(result, preparedStatementType);
+  }
+  /**
+   * Same as `DuckDBResult.closeSync`; the row and chunk counts also stay
+   * available. Getting a chunk throws.
+   */
+  public override closeSync() {
+    if (!this.closedCounts) {
+      this.closedCounts = {
+        rowCount: this.rowCount,
+        chunkCount: this.chunkCount,
+      };
+    }
+    super.closeSync();
+  }
+  public get rowCount(): number {
+    if (this.closedCounts) {
+      return this.closedCounts.rowCount;
+    }
+    return duckdb.row_count(this.result);
+  }
+  public get chunkCount(): number {
+    if (this.closedCounts) {
+      return this.closedCounts.chunkCount;
+    }
+    return duckdb.result_chunk_count(this.result);
+  }
+  public getChunk(chunkIndex: number): DuckDBDataChunk {
+    return new DuckDBDataChunk(duckdb.result_get_chunk(this.result, chunkIndex));
+  }
+}

package/vendor/node-api/src/DuckDBPendingResult.ts

@@ -0,0 +1,83 @@
+import duckdb from "../../../src/bindings/index.ts";
+import { createResult } from './createResult';
+import { DuckDBResult } from './DuckDBResult';
+import { DuckDBResultReader } from './DuckDBResultReader';
+import { StatementType } from './enums';
+import { sleep } from './sleep';
+
+// Values match similar enum in C API.
+export enum DuckDBPendingResultState {
+  RESULT_READY = 0,
+  RESULT_NOT_READY = 1,
+  NO_TASKS_AVAILABLE = 3,
+}
+
+export class DuckDBPendingResult {
+  private readonly pending_result: duckdb.PendingResult;
+  private readonly preparedStatementType: StatementType | undefined;
+  /**
+   * `preparedStatementType` is passed on to the result; see `DuckDBResult`.
+   */
+  constructor(
+    pending_result: duckdb.PendingResult,
+    preparedStatementType?: StatementType
+  ) {
+    this.pending_result = pending_result;
+    this.preparedStatementType = preparedStatementType;
+  }
+  /**
+   * Destroys the pending result. On DuckDB 2.0, a pending result whose result
+   * has not been gotten blocks its connection from starting another statement
+   * until it is closed.
+   *
+   * Running tasks or getting the result afterwards throws. If getting the
+   * result is in flight, the pending result is destroyed once it finishes; the
+   * result it returns is unaffected. Closing again does nothing.
+   */
+  public closeSync() {
+    duckdb.destroy_pending_sync(this.pending_result);
+  }
+  public runTask(): DuckDBPendingResultState {
+    const pending_state = duckdb.pending_execute_task(this.pending_result);
+    switch (pending_state) {
+      case duckdb.PendingState.RESULT_READY:
+        return DuckDBPendingResultState.RESULT_READY;
+      case duckdb.PendingState.RESULT_NOT_READY:
+        return DuckDBPendingResultState.RESULT_NOT_READY;
+      case duckdb.PendingState.ERROR:
+        throw new Error(
+          `Failure running pending result task: ${duckdb.pending_error(
+            this.pending_result
+          )}`
+        );
+      case duckdb.PendingState.NO_TASKS_AVAILABLE:
+        return DuckDBPendingResultState.NO_TASKS_AVAILABLE;
+      default:
+        throw new Error(`Unexpected pending state: ${pending_state}`);
+    }
+  }
+  public async runAllTasks(): Promise<void> {
+    while (this.runTask() !== DuckDBPendingResultState.RESULT_READY) {
+      await sleep(1);
+    }
+  }
+  public async getResult(): Promise<DuckDBResult> {
+    return createResult(
+      await duckdb.execute_pending(this.pending_result),
+      this.preparedStatementType
+    );
+  }
+  public async read(): Promise<DuckDBResultReader> {
+    return new DuckDBResultReader(await this.getResult());
+  }
+  public async readAll(): Promise<DuckDBResultReader> {
+    const reader = new DuckDBResultReader(await this.getResult());
+    await reader.readAll();
+    return reader;
+  }
+  public async readUntil(targetRowCount: number): Promise<DuckDBResultReader> {
+    const reader = new DuckDBResultReader(await this.getResult());
+    await reader.readUntil(targetRowCount);
+    return reader;
+  }
+}