@avidian/duckdb-bun 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,237 @@
+import duckdb from "../../../src/bindings/index.ts";
+import { createValue } from './createValue';
+import { DuckDBConnection } from './DuckDBConnection';
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBLogicalType } from './DuckDBLogicalType';
+import {
+  BIGNUM,
+  BIT,
+  DECIMAL,
+  DuckDBArrayType,
+  DuckDBEnumType,
+  DuckDBListType,
+  DuckDBMapType,
+  DuckDBStructType,
+  DuckDBType,
+  DuckDBUnionType,
+  TIMESTAMP_MS,
+  TIMESTAMP_NS,
+  TIMESTAMP_S,
+  TIMESTAMPTZ,
+  TIMESTAMPTZ_NS,
+  TIMETZ,
+  UUID,
+  VARIANT,
+} from './DuckDBType';
+import { typeForValue } from './typeForValue';
+import {
+  arrayValue,
+  DuckDBArrayValue,
+  DuckDBBitValue,
+  DuckDBDateValue,
+  DuckDBDecimalValue,
+  DuckDBIntervalValue,
+  DuckDBListValue,
+  DuckDBMapValue,
+  DuckDBStructValue,
+  DuckDBTimestampMillisecondsValue,
+  DuckDBTimestampNanosecondsValue,
+  DuckDBTimestampSecondsValue,
+  DuckDBTimestampTZValue,
+  DuckDBTimestampTZNanosecondsValue,
+  DuckDBTimestampValue,
+  DuckDBTimeTZValue,
+  DuckDBTimeValue,
+  DuckDBTupleValue,
+  DuckDBUnionValue,
+  DuckDBUUIDValue,
+  DuckDBValue,
+  DuckDBVariantValue,
+  listValue,
+  structValue,
+  tupleValue,
+} from './values';
+
+export class DuckDBAppender {
+  public readonly connection: DuckDBConnection;
+  private readonly appender: duckdb.Appender;
+  constructor(connection: DuckDBConnection, appender: duckdb.Appender) {
+    this.connection = connection;
+    this.appender = appender;
+  }
+  public closeSync() {
+    duckdb.appender_close_sync(this.appender);
+  }
+  public flushSync() {
+    duckdb.appender_flush_sync(this.appender);
+  }
+  public clear() {
+    duckdb.appender_clear(this.appender);
+  }
+  public get columnCount(): number {
+    return duckdb.appender_column_count(this.appender);
+  }
+  public columnType(columnIndex: number): DuckDBType {
+    return DuckDBLogicalType.create(
+      duckdb.appender_column_type(this.appender, columnIndex)
+    ).asType();
+  }
+  public endRow() {
+    duckdb.appender_end_row(this.appender);
+  }
+  public appendDefault() {
+    duckdb.append_default(this.appender);
+  }
+  public appendBoolean(value: boolean) {
+    duckdb.append_bool(this.appender, value);
+  }
+  public appendTinyInt(value: number) {
+    duckdb.append_int8(this.appender, value);
+  }
+  public appendSmallInt(value: number) {
+    duckdb.append_int16(this.appender, value);
+  }
+  public appendInteger(value: number) {
+    duckdb.append_int32(this.appender, value);
+  }
+  public appendBigInt(value: bigint) {
+    duckdb.append_int64(this.appender, value);
+  }
+  public appendHugeInt(value: bigint) {
+    duckdb.append_hugeint(this.appender, value);
+  }
+  public appendUTinyInt(value: number) {
+    duckdb.append_uint8(this.appender, value);
+  }
+  public appendUSmallInt(value: number) {
+    duckdb.append_uint16(this.appender, value);
+  }
+  public appendUInteger(value: number) {
+    duckdb.append_uint32(this.appender, value);
+  }
+  public appendUBigInt(value: bigint) {
+    duckdb.append_uint64(this.appender, value);
+  }
+  public appendUHugeInt(value: bigint) {
+    duckdb.append_uhugeint(this.appender, value);
+  }
+  public appendDecimal(value: DuckDBDecimalValue) {
+    // The width and scale of the DECIMAL type here aren't actually used.
+    this.appendValue(value, DECIMAL(value.width, value.scale));
+  }
+  public appendFloat(value: number) {
+    duckdb.append_float(this.appender, value);
+  }
+  public appendDouble(value: number) {
+    duckdb.append_double(this.appender, value);
+  }
+  public appendDate(value: DuckDBDateValue) {
+    duckdb.append_date(this.appender, value);
+  }
+  public appendTime(value: DuckDBTimeValue) {
+    duckdb.append_time(this.appender, value);
+  }
+  public appendTimeTZ(value: DuckDBTimeTZValue) {
+    this.appendValue(value, TIMETZ);
+  }
+  public appendTimestamp(value: DuckDBTimestampValue) {
+    duckdb.append_timestamp(this.appender, value);
+  }
+  public appendTimestampTZ(value: DuckDBTimestampTZValue) {
+    this.appendValue(value, TIMESTAMPTZ);
+  }
+  public appendTimestampTZNanoseconds(value: DuckDBTimestampTZNanosecondsValue) {
+    this.appendValue(value, TIMESTAMPTZ_NS);
+  }
+  public appendTimestampSeconds(value: DuckDBTimestampSecondsValue) {
+    this.appendValue(value, TIMESTAMP_S);
+  }
+  public appendTimestampMilliseconds(value: DuckDBTimestampMillisecondsValue) {
+    this.appendValue(value, TIMESTAMP_MS);
+  }
+  public appendTimestampNanoseconds(value: DuckDBTimestampNanosecondsValue) {
+    this.appendValue(value, TIMESTAMP_NS);
+  }
+  public appendInterval(value: DuckDBIntervalValue) {
+    duckdb.append_interval(this.appender, value);
+  }
+  public appendVarchar(value: string) {
+    duckdb.append_varchar(this.appender, value);
+  }
+  public appendBlob(value: Uint8Array) {
+    duckdb.append_blob(this.appender, value);
+  }
+  public appendEnum(value: string, type: DuckDBEnumType) {
+    this.appendValue(value, type);
+  }
+  public appendList(
+    value: DuckDBListValue | readonly DuckDBValue[],
+    type?: DuckDBListType
+  ) {
+    this.appendValue(
+      value instanceof DuckDBListValue ? value : listValue(value),
+      type
+    );
+  }
+  public appendStruct(
+    value: DuckDBStructValue | Readonly<Record<string, DuckDBValue>>,
+    type?: DuckDBStructType
+  ) {
+    this.appendValue(
+      value instanceof DuckDBStructValue ? value : structValue(value),
+      type
+    );
+  }
+  public appendTuple(
+    value: DuckDBTupleValue | readonly DuckDBValue[],
+    type?: DuckDBStructType
+  ) {
+    this.appendValue(
+      value instanceof DuckDBTupleValue ? value : tupleValue(value),
+      type
+    );
+  }
+  public appendMap(value: DuckDBMapValue, type?: DuckDBMapType) {
+    this.appendValue(value, type);
+  }
+  public appendArray(
+    value: DuckDBArrayValue | readonly DuckDBValue[],
+    type?: DuckDBArrayType
+  ) {
+    this.appendValue(
+      value instanceof DuckDBArrayValue ? value : arrayValue(value),
+      type
+    );
+  }
+  public appendUnion(value: DuckDBUnionValue, type?: DuckDBUnionType) {
+    this.appendValue(value, type);
+  }
+  public appendUUID(value: DuckDBUUIDValue) {
+    this.appendValue(value, UUID);
+  }
+  public appendBit(value: DuckDBBitValue) {
+    this.appendValue(value, BIT);
+  }
+  public appendBigNum(value: bigint) {
+    this.appendValue(value, BIGNUM);
+  }
+  public appendVariant(value: DuckDBVariantValue | null) {
+    if (value === null) {
+      this.appendNull();
+      return;
+    }
+    this.appendValue(value, VARIANT);
+  }
+  public appendNull() {
+    duckdb.append_null(this.appender);
+  }
+  public appendValue(value: DuckDBValue, type?: DuckDBType) {
+    duckdb.append_value(
+      this.appender,
+      createValue(type ? type : typeForValue(value), value)
+    );
+  }
+  public appendDataChunk(dataChunk: DuckDBDataChunk) {
+    duckdb.append_data_chunk(this.appender, dataChunk.chunk);
+  }
+}

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

@@ -0,0 +1,13 @@
+import duckdb from "../../../src/bindings/index.ts";
+
+export class DuckDBClientContext {
+  private readonly client_context: duckdb.ClientContext;
+
+  constructor(client_context: duckdb.ClientContext) {
+    this.client_context = client_context;
+  }
+
+  public get connectionId(): number {
+    return duckdb.client_context_get_connection_id(this.client_context);
+  }
+}

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

@@ -0,0 +1,315 @@
+import duckdb from "../../../src/bindings/index.ts";
+import { DuckDBAppender } from './DuckDBAppender';
+import { DuckDBClientContext } from './DuckDBClientContext';
+import { DuckDBExtractedStatements } from './DuckDBExtractedStatements';
+import { DuckDBInstance } from './DuckDBInstance';
+import { DuckDBMaterializedResult } from './DuckDBMaterializedResult';
+import { DuckDBPendingResult } from './DuckDBPendingResult';
+import { DuckDBPreparedStatement } from './DuckDBPreparedStatement';
+import { DuckDBPreparedStatementWeakRefCollection } from './DuckDBPreparedStatementWeakRefCollection';
+import { DuckDBResult } from './DuckDBResult';
+import { DuckDBResultReader } from './DuckDBResultReader';
+import { DuckDBScalarFunction } from './DuckDBScalarFunction';
+import { DuckDBTableFunction } from './DuckDBTableFunction';
+import { DuckDBType } from './DuckDBType';
+import { DuckDBValue } from './values';
+
+export class DuckDBConnection {
+  private readonly connection: duckdb.Connection;
+  private readonly preparedStatements: DuckDBPreparedStatementWeakRefCollection;
+  constructor(connection: duckdb.Connection) {
+    this.connection = connection;
+    this.preparedStatements = new DuckDBPreparedStatementWeakRefCollection();
+  }
+  public static async create(
+    instance?: DuckDBInstance
+  ): Promise<DuckDBConnection> {
+    if (instance) {
+      return instance.connect();
+    }
+    return (await DuckDBInstance.fromCache()).connect();
+  }
+  /** Same as disconnectSync. */
+  public closeSync() {
+    this.disconnectSync();
+  }
+  public disconnectSync() {
+    this.preparedStatements.destroySync();
+    duckdb.disconnect_sync(this.connection);
+  }
+  public get clientContext(): DuckDBClientContext {
+    return this.getClientContext();
+  }
+  public getClientContext(): DuckDBClientContext {
+    return new DuckDBClientContext(
+      duckdb.connection_get_client_context(this.connection)
+    );
+  }
+  public interrupt() {
+    duckdb.interrupt(this.connection);
+  }
+  public get progress(): duckdb.QueryProgress {
+    return duckdb.query_progress(this.connection);
+  }
+  public async run(
+    sql: string,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBMaterializedResult> {
+    if (values) {
+      const prepared = await this.runUntilLast(sql);
+      try {
+        prepared.bind(values, types);
+        const result = await prepared.run();
+        return result;
+      } finally {
+        prepared.destroySync();
+      }
+    } else {
+      return new DuckDBMaterializedResult(
+        await duckdb.query(this.connection, sql)
+      );
+    }
+  }
+  public async runAndRead(
+    sql: string,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBResultReader> {
+    return new DuckDBResultReader(await this.run(sql, values, types));
+  }
+  public async runAndReadAll(
+    sql: string,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBResultReader> {
+    const reader = await this.runAndRead(sql, values, types);
+    await reader.readAll();
+    return reader;
+  }
+  public async runAndReadUntil(
+    sql: string,
+    targetRowCount: number,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBResultReader> {
+    const reader = await this.runAndRead(sql, values, types);
+    await reader.readUntil(targetRowCount);
+    return reader;
+  }
+  public async stream(
+    sql: string,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBResult> {
+    const prepared = await this.runUntilLast(sql);
+    try {
+      if (values) {
+        prepared.bind(values, types);
+      }
+      const result = await prepared.stream();
+      return result;
+    } finally {
+      prepared.destroySync();
+    }
+  }
+  public async streamAndRead(
+    sql: string,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBResultReader> {
+    return new DuckDBResultReader(await this.stream(sql, values, types));
+  }
+  public async streamAndReadAll(
+    sql: string,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBResultReader> {
+    const reader = await this.streamAndRead(sql, values, types);
+    await reader.readAll();
+    return reader;
+  }
+  public async streamAndReadUntil(
+    sql: string,
+    targetRowCount: number,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBResultReader> {
+    const reader = await this.streamAndRead(sql, values, types);
+    await reader.readUntil(targetRowCount);
+    return reader;
+  }
+  public async start(
+    sql: string,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBPendingResult> {
+    const prepared = await this.runUntilLast(sql);
+    try {
+      if (values) {
+        prepared.bind(values, types);
+      }
+      return prepared.start();
+    } finally {
+      prepared.destroySync();
+    }
+  }
+  public async startThenRead(
+    sql: string,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBResultReader> {
+    const pending = await this.start(sql, values, types);
+    await pending.runAllTasks();
+    return new DuckDBResultReader(await pending.getResult());
+  }
+  public async startThenReadAll(
+    sql: string,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBResultReader> {
+    const reader = await this.startThenRead(sql, values, types);
+    await reader.readAll();
+    return reader;
+  }
+  public async startThenReadUntil(
+    sql: string,
+    targetRowCount: number,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBResultReader> {
+    const reader = await this.startThenRead(sql, values, types);
+    await reader.readUntil(targetRowCount);
+    return reader;
+  }
+  public async startStream(
+    sql: string,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBPendingResult> {
+    const prepared = await this.runUntilLast(sql);
+    try {
+      if (values) {
+        prepared.bind(values, types);
+      }
+      return prepared.startStream();
+    } finally {
+      prepared.destroySync();
+    }
+  }
+  public async startStreamThenRead(
+    sql: string,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBResultReader> {
+    const pending = await this.startStream(sql, values, types);
+    await pending.runAllTasks();
+    return new DuckDBResultReader(await pending.getResult());
+  }
+  public async startStreamThenReadAll(
+    sql: string,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBResultReader> {
+    const reader = await this.startStreamThenRead(sql, values, types);
+    await reader.readAll();
+    return reader;
+  }
+  public async startStreamThenReadUntil(
+    sql: string,
+    targetRowCount: number,
+    values?: DuckDBValue[] | Record<string, DuckDBValue>,
+    types?: DuckDBType[] | Record<string, DuckDBType | undefined>
+  ): Promise<DuckDBResultReader> {
+    const reader = await this.startStreamThenRead(sql, values, types);
+    await reader.readUntil(targetRowCount);
+    return reader;
+  }
+  public async prepare(sql: string): Promise<DuckDBPreparedStatement> {
+    const prepared = await this.createPrepared(sql);
+    this.preparedStatements.add(prepared);
+    return prepared;
+  }
+  private async createPrepared(sql: string): Promise<DuckDBPreparedStatement> {
+    return new DuckDBPreparedStatement(
+      await duckdb.prepare(this.connection, sql)
+    );
+  }
+  public async extractStatements(
+    sql: string
+  ): Promise<DuckDBExtractedStatements> {
+    const { extracted_statements, statement_count } =
+      await duckdb.extract_statements(this.connection, sql);
+    if (statement_count === 0) {
+      throw new Error(
+        `Failed to extract statements: ${duckdb.extract_statements_error(
+          extracted_statements
+        )}`
+      );
+    }
+    return new DuckDBExtractedStatements(
+      this.connection,
+      extracted_statements,
+      statement_count,
+      this.preparedStatements
+    );
+  }
+  private async runUntilLast(sql: string): Promise<DuckDBPreparedStatement> {
+    const extractedStatements = await this.extractStatements(sql);
+    const statementCount = extractedStatements.count;
+    if (statementCount > 1) {
+      for (let i = 0; i < statementCount - 1; i++) {
+        const prepared = await extractedStatements.prepare(i);
+        try {
+          await prepared.run();
+        } finally {
+          prepared.destroySync();
+        }
+      }
+    }
+    return extractedStatements.prepare(statementCount - 1);
+  }
+  public getTableNames(query: string, qualified: boolean): readonly string[] {
+    const names: string[] = [];
+    const list_value = duckdb.get_table_names(
+      this.connection,
+      query,
+      qualified
+    );
+    const count = duckdb.get_list_size(list_value);
+    for (let i = 0; i < count; i++) {
+      const varchar_value = duckdb.get_list_child(list_value, i);
+      const name = duckdb.get_varchar(varchar_value);
+      names.push(name);
+    }
+    names.sort();
+    return names;
+  }
+  public async createAppender(
+    table: string,
+    schema?: string | null,
+    catalog?: string | null
+  ): Promise<DuckDBAppender> {
+    return new DuckDBAppender(
+      this,
+      duckdb.appender_create_ext(
+        this.connection,
+        catalog ?? null,
+        schema ?? null,
+        table
+      )
+    );
+  }
+  public registerTableFunction(tableFunction: DuckDBTableFunction) {
+    duckdb.register_table_function(
+      this.connection,
+      tableFunction.table_function
+    );
+  }
+  public registerScalarFunction(scalarFunction: DuckDBScalarFunction) {
+    duckdb.register_scalar_function(
+      this.connection,
+      scalarFunction.scalar_function
+    );
+  }
+}