@avidian/duckdb-bun 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,149 @@
+import duckdb from "../../../src/bindings/index.ts";
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBScalarFunctionBindInfo } from './DuckDBScalarFunctionBindInfo';
+import { DuckDBScalarFunctionInfo } from './DuckDBScalarFunctionInfo';
+import { DuckDBScalarFunctionInitInfo } from './DuckDBScalarFunctionInitInfo';
+import { DuckDBType } from './DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+
+export type DuckDBScalarBindFunction = (bindInfo: DuckDBScalarFunctionBindInfo) => void;
+
+export type DuckDBScalarInitFunction = (
+  initInfo: DuckDBScalarFunctionInitInfo,
+) => void;
+
+export type DuckDBScalarMainFunction = (
+  functionInfo: DuckDBScalarFunctionInfo,
+  inputDataChunk: DuckDBDataChunk,
+  outputVector: DuckDBVector,
+) => void;
+
+export class DuckDBScalarFunction {
+  readonly scalar_function: duckdb.ScalarFunction;
+
+  public constructor() {
+    this.scalar_function = duckdb.create_scalar_function();
+  }
+
+  public static create({
+    name,
+    bindFunction,
+    initFunction,
+    mainFunction,
+    returnType,
+    parameterTypes,
+    varArgsType,
+    specialHandling,
+    volatile,
+    extraInfo,
+  }: {
+    name: string;
+    bindFunction?: DuckDBScalarBindFunction;
+    initFunction?: DuckDBScalarInitFunction;
+    mainFunction: DuckDBScalarMainFunction;
+    returnType: DuckDBType;
+    parameterTypes?: readonly DuckDBType[];
+    varArgsType?: DuckDBType;
+    specialHandling?: boolean;
+    volatile?: boolean;
+    extraInfo?: object;
+  }): DuckDBScalarFunction {
+    const scalarFunction = new DuckDBScalarFunction();
+    scalarFunction.setName(name);
+    if (bindFunction) {
+      scalarFunction.setBindFunction(bindFunction);
+    }
+    if (initFunction) {
+      scalarFunction.setInitFunction(initFunction);
+    }
+    scalarFunction.setMainFunction(mainFunction);
+    scalarFunction.setReturnType(returnType);
+    if (parameterTypes) {
+      for (const parameterType of parameterTypes) {
+        scalarFunction.addParameter(parameterType);
+      }
+    }
+    if (varArgsType) {
+      scalarFunction.setVarArgs(varArgsType);
+    }
+    if (specialHandling) {
+      scalarFunction.setSpecialHandling();
+    }
+    if (volatile) {
+      scalarFunction.setVolatile();
+    }
+    if (extraInfo) {
+      scalarFunction.setExtraInfo(extraInfo);
+    }
+    return scalarFunction;
+  }
+
+  public destroySync() {
+    duckdb.destroy_scalar_function_sync(this.scalar_function);
+  }
+
+  public setName(name: string) {
+    duckdb.scalar_function_set_name(this.scalar_function, name);
+  }
+
+  public setBindFunction(bindFunction: DuckDBScalarBindFunction) {
+    duckdb.scalar_function_set_bind(this.scalar_function, (info) => {
+      const bindInfo = new DuckDBScalarFunctionBindInfo(info);
+      bindFunction(bindInfo);
+    });
+  }
+
+  public setInitFunction(initFunction: DuckDBScalarInitFunction) {
+    duckdb.scalar_function_set_init(this.scalar_function, (info) => {
+      initFunction(new DuckDBScalarFunctionInitInfo(info));
+    });
+  }
+
+  public setMainFunction(mainFunction: DuckDBScalarMainFunction) {
+    duckdb.scalar_function_set_function(
+      this.scalar_function,
+      (info, input, output) => {
+        const functionInfo = new DuckDBScalarFunctionInfo(info);
+        const inputDataChunk = new DuckDBDataChunk(input);
+        const outputVector = DuckDBVector.create(
+          output,
+          inputDataChunk.rowCount,
+        );
+        mainFunction(functionInfo, inputDataChunk, outputVector);
+      },
+    );
+  }
+
+  public setReturnType(returnType: DuckDBType) {
+    duckdb.scalar_function_set_return_type(
+      this.scalar_function,
+      returnType.toLogicalType().logical_type,
+    );
+  }
+
+  public addParameter(parameterType: DuckDBType) {
+    duckdb.scalar_function_add_parameter(
+      this.scalar_function,
+      parameterType.toLogicalType().logical_type,
+    );
+  }
+
+  public setVarArgs(varArgsType: DuckDBType) {
+    duckdb.scalar_function_set_varargs(
+      this.scalar_function,
+      varArgsType.toLogicalType().logical_type,
+    );
+  }
+
+  public setSpecialHandling() {
+    duckdb.scalar_function_set_special_handling(this.scalar_function);
+  }
+
+  public setVolatile() {
+    duckdb.scalar_function_set_volatile(this.scalar_function);
+  }
+
+  public setExtraInfo(extraInfo: object) {
+    duckdb.scalar_function_set_extra_info(this.scalar_function, extraInfo);
+  }
+}

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

@@ -0,0 +1,34 @@
+import duckdb from "../../../src/bindings/index.ts";
+import { DuckDBClientContext } from './DuckDBClientContext';
+
+export class DuckDBScalarFunctionBindInfo {
+  private readonly bind_info: duckdb.ScalarFunctionBindInfo;
+  constructor(bind_info: duckdb.ScalarFunctionBindInfo) {
+    this.bind_info = bind_info;
+  }
+  public get clientContext(): DuckDBClientContext {
+    return this.getClientContext();
+  }
+  public getClientContext(): DuckDBClientContext {
+    return new DuckDBClientContext(
+      duckdb.scalar_function_get_client_context(this.bind_info),
+    );
+  }
+  public get extraInfo(): object | undefined {
+    return this.getExtraInfo();
+  }
+  public getExtraInfo(): object | undefined {
+    return duckdb.scalar_function_bind_get_extra_info(this.bind_info);
+  }
+  public setBindData(bindData: object) {
+    duckdb.scalar_function_set_bind_data(this.bind_info, bindData);
+  }
+  public setError(error: string) {
+    duckdb.scalar_function_bind_set_error(this.bind_info, error);
+  }
+}
+
+/** @deprecated Renamed to DuckDBScalarFunctionBindInfo. */
+export const DuckDBBindInfo = DuckDBScalarFunctionBindInfo;
+/** @deprecated Renamed to DuckDBScalarFunctionBindInfo. */
+export type DuckDBBindInfo = DuckDBScalarFunctionBindInfo;

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

@@ -0,0 +1,34 @@
+import duckdb from "../../../src/bindings/index.ts";
+
+export class DuckDBScalarFunctionInfo {
+  private readonly function_info: duckdb.ScalarFunctionInfo;
+  constructor(function_info: duckdb.ScalarFunctionInfo) {
+    this.function_info = function_info;
+  }
+  public get bindData(): object | undefined {
+    return this.getBindData();
+  }
+  public getBindData(): object | undefined {
+    return duckdb.scalar_function_get_bind_data(this.function_info);
+  }
+  public get extraInfo(): object | undefined {
+    return this.getExtraInfo();
+  }
+  public getExtraInfo(): object | undefined {
+    return duckdb.scalar_function_get_extra_info(this.function_info);
+  }
+  public get state(): object | undefined {
+    return this.getState();
+  }
+  public getState(): object | undefined {
+    return duckdb.scalar_function_get_state(this.function_info);
+  }
+  public setError(error: string) {
+    duckdb.scalar_function_set_error(this.function_info, error);
+  }
+}
+
+/** @deprecated Renamed to DuckDBScalarFunctionInfo. */
+export const DuckDBFunctionInfo = DuckDBScalarFunctionInfo;
+/** @deprecated Renamed to DuckDBScalarFunctionInfo. */
+export type DuckDBFunctionInfo = DuckDBScalarFunctionInfo;

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

@@ -0,0 +1,35 @@
+import duckdb from "../../../src/bindings/index.ts";
+import { DuckDBClientContext } from './DuckDBClientContext';
+
+export class DuckDBScalarFunctionInitInfo {
+  private readonly init_info: duckdb.ScalarFunctionInitInfo;
+  constructor(init_info: duckdb.ScalarFunctionInitInfo) {
+    this.init_info = init_info;
+  }
+  public get clientContext(): DuckDBClientContext {
+    return this.getClientContext();
+  }
+  public getClientContext(): DuckDBClientContext {
+    return new DuckDBClientContext(
+      duckdb.scalar_function_init_get_client_context(this.init_info),
+    );
+  }
+  public get extraInfo(): object | undefined {
+    return this.getExtraInfo();
+  }
+  public getExtraInfo(): object | undefined {
+    return duckdb.scalar_function_init_get_extra_info(this.init_info);
+  }
+  public get bindData(): object | undefined {
+    return this.getBindData();
+  }
+  public getBindData(): object | undefined {
+    return duckdb.scalar_function_init_get_bind_data(this.init_info);
+  }
+  public setState(state: object) {
+    duckdb.scalar_function_init_set_state(this.init_info, state);
+  }
+  public setError(error: string) {
+    duckdb.scalar_function_init_set_error(this.init_info, error);
+  }
+}

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

@@ -0,0 +1,149 @@
+import duckdb from "../../../src/bindings/index.ts";
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBTableFunctionBindInfo } from './DuckDBTableFunctionBindInfo';
+import { DuckDBTableFunctionInfo } from './DuckDBTableFunctionInfo';
+import { DuckDBTableFunctionInitInfo } from './DuckDBTableFunctionInitInfo';
+import { DuckDBType } from './DuckDBType';
+
+export type DuckDBTableBindFunction = (
+  bindInfo: DuckDBTableFunctionBindInfo,
+) => void;
+
+export type DuckDBTableInitFunction = (
+  initInfo: DuckDBTableFunctionInitInfo,
+) => void;
+
+/**
+ * Produces one chunk of the scan per call.
+ *
+ * Set `outputDataChunk.rowCount` before writing, then write that many rows to
+ * each column vector. A row count of zero reports that the scan is finished, so
+ * a function that never sets zero never terminates.
+ */
+export type DuckDBTableMainFunction = (
+  functionInfo: DuckDBTableFunctionInfo,
+  outputDataChunk: DuckDBDataChunk,
+) => void;
+
+export class DuckDBTableFunction {
+  readonly table_function: duckdb.TableFunction;
+
+  public constructor() {
+    this.table_function = duckdb.create_table_function();
+  }
+
+  public static create({
+    name,
+    bindFunction,
+    initFunction,
+    localInitFunction,
+    mainFunction,
+    parameterTypes,
+    namedParameterTypes,
+    supportsProjectionPushdown,
+    extraInfo,
+  }: {
+    name: string;
+    bindFunction: DuckDBTableBindFunction;
+    initFunction: DuckDBTableInitFunction;
+    localInitFunction?: DuckDBTableInitFunction;
+    mainFunction: DuckDBTableMainFunction;
+    parameterTypes?: readonly DuckDBType[];
+    namedParameterTypes?: Readonly<Record<string, DuckDBType>>;
+    supportsProjectionPushdown?: boolean;
+    extraInfo?: object;
+  }): DuckDBTableFunction {
+    const tableFunction = new DuckDBTableFunction();
+    tableFunction.setName(name);
+    tableFunction.setBindFunction(bindFunction);
+    tableFunction.setInitFunction(initFunction);
+    if (localInitFunction) {
+      tableFunction.setLocalInitFunction(localInitFunction);
+    }
+    tableFunction.setMainFunction(mainFunction);
+    if (parameterTypes) {
+      for (const parameterType of parameterTypes) {
+        tableFunction.addParameter(parameterType);
+      }
+    }
+    if (namedParameterTypes) {
+      for (const [
+        parameterName,
+        parameterType,
+      ] of Object.entries(namedParameterTypes)) {
+        tableFunction.addNamedParameter(parameterName, parameterType);
+      }
+    }
+    if (supportsProjectionPushdown) {
+      tableFunction.setSupportsProjectionPushdown(true);
+    }
+    if (extraInfo) {
+      tableFunction.setExtraInfo(extraInfo);
+    }
+    return tableFunction;
+  }
+
+  public destroySync() {
+    duckdb.destroy_table_function_sync(this.table_function);
+  }
+
+  public setName(name: string) {
+    duckdb.table_function_set_name(this.table_function, name);
+  }
+
+  public setBindFunction(bindFunction: DuckDBTableBindFunction) {
+    duckdb.table_function_set_bind(this.table_function, (info) => {
+      bindFunction(new DuckDBTableFunctionBindInfo(info));
+    });
+  }
+
+  public setInitFunction(initFunction: DuckDBTableInitFunction) {
+    duckdb.table_function_set_init(this.table_function, (info) => {
+      initFunction(new DuckDBTableFunctionInitInfo(info));
+    });
+  }
+
+  public setLocalInitFunction(localInitFunction: DuckDBTableInitFunction) {
+    duckdb.table_function_set_local_init(this.table_function, (info) => {
+      localInitFunction(new DuckDBTableFunctionInitInfo(info));
+    });
+  }
+
+  public setMainFunction(mainFunction: DuckDBTableMainFunction) {
+    duckdb.table_function_set_function(
+      this.table_function,
+      (info, output) => {
+        mainFunction(
+          new DuckDBTableFunctionInfo(info),
+          new DuckDBDataChunk(output),
+        );
+      },
+    );
+  }
+
+  public addParameter(parameterType: DuckDBType) {
+    duckdb.table_function_add_parameter(
+      this.table_function,
+      parameterType.toLogicalType().logical_type,
+    );
+  }
+
+  public addNamedParameter(name: string, parameterType: DuckDBType) {
+    duckdb.table_function_add_named_parameter(
+      this.table_function,
+      name,
+      parameterType.toLogicalType().logical_type,
+    );
+  }
+
+  public setSupportsProjectionPushdown(pushdown: boolean) {
+    duckdb.table_function_supports_projection_pushdown(
+      this.table_function,
+      pushdown,
+    );
+  }
+
+  public setExtraInfo(extraInfo: object) {
+    duckdb.table_function_set_extra_info(this.table_function, extraInfo);
+  }
+}

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

@@ -0,0 +1,56 @@
+import duckdb from "../../../src/bindings/index.ts";
+import { DuckDBClientContext } from './DuckDBClientContext';
+import { DuckDBType } from './DuckDBType';
+import { readValue } from './readValue';
+import { DuckDBValue } from './values';
+
+export class DuckDBTableFunctionBindInfo {
+  private readonly bind_info: duckdb.TableFunctionBindInfo;
+  constructor(bind_info: duckdb.TableFunctionBindInfo) {
+    this.bind_info = bind_info;
+  }
+  public get clientContext(): DuckDBClientContext {
+    return this.getClientContext();
+  }
+  public getClientContext(): DuckDBClientContext {
+    return new DuckDBClientContext(
+      duckdb.table_function_get_client_context(this.bind_info),
+    );
+  }
+  public get extraInfo(): object | undefined {
+    return this.getExtraInfo();
+  }
+  public getExtraInfo(): object | undefined {
+    return duckdb.bind_get_extra_info(this.bind_info);
+  }
+  public get parameterCount(): number {
+    return this.getParameterCount();
+  }
+  public getParameterCount(): number {
+    return duckdb.bind_get_parameter_count(this.bind_info);
+  }
+  public getParameter(index: number): DuckDBValue {
+    return readValue(duckdb.bind_get_parameter(this.bind_info, index));
+  }
+  /** Returns null if no parameter with this name was supplied. */
+  public getNamedParameter(name: string): DuckDBValue | null {
+    const value = duckdb.bind_get_named_parameter(this.bind_info, name);
+    return value === null ? null : readValue(value);
+  }
+  public addResultColumn(name: string, type: DuckDBType) {
+    duckdb.bind_add_result_column(
+      this.bind_info,
+      name,
+      type.toLogicalType().logical_type,
+    );
+  }
+  public setBindData(bindData: object) {
+    duckdb.bind_set_bind_data(this.bind_info, bindData);
+  }
+  public setCardinality(cardinality: number, isExact: boolean) {
+    duckdb.bind_set_cardinality(this.bind_info, cardinality, isExact);
+  }
+  public setError(error: string) {
+    duckdb.bind_set_error(this.bind_info, error);
+  }
+}

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

@@ -0,0 +1,36 @@
+import duckdb from "../../../src/bindings/index.ts";
+
+export class DuckDBTableFunctionInfo {
+  private readonly function_info: duckdb.TableFunctionInfo;
+  constructor(function_info: duckdb.TableFunctionInfo) {
+    this.function_info = function_info;
+  }
+  public get extraInfo(): object | undefined {
+    return this.getExtraInfo();
+  }
+  public getExtraInfo(): object | undefined {
+    return duckdb.function_get_extra_info(this.function_info);
+  }
+  public get bindData(): object | undefined {
+    return this.getBindData();
+  }
+  public getBindData(): object | undefined {
+    return duckdb.function_get_bind_data(this.function_info);
+  }
+  public get initData(): object | undefined {
+    return this.getInitData();
+  }
+  public getInitData(): object | undefined {
+    return duckdb.function_get_init_data(this.function_info);
+  }
+  /** The init data set by the local init function, which is per scanning thread. */
+  public get localInitData(): object | undefined {
+    return this.getLocalInitData();
+  }
+  public getLocalInitData(): object | undefined {
+    return duckdb.function_get_local_init_data(this.function_info);
+  }
+  public setError(error: string) {
+    duckdb.function_set_error(this.function_info, error);
+  }
+}

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

@@ -0,0 +1,52 @@
+import duckdb from "../../../src/bindings/index.ts";
+
+export class DuckDBTableFunctionInitInfo {
+  private readonly init_info: duckdb.TableFunctionInitInfo;
+  constructor(init_info: duckdb.TableFunctionInitInfo) {
+    this.init_info = init_info;
+  }
+  public get extraInfo(): object | undefined {
+    return this.getExtraInfo();
+  }
+  public getExtraInfo(): object | undefined {
+    return duckdb.init_get_extra_info(this.init_info);
+  }
+  public get bindData(): object | undefined {
+    return this.getBindData();
+  }
+  public getBindData(): object | undefined {
+    return duckdb.init_get_bind_data(this.init_info);
+  }
+  /**
+   * The number of columns the scan has been asked for, which is all of them
+   * unless the function opted into projection pushdown.
+   */
+  public get columnCount(): number {
+    return this.getColumnCount();
+  }
+  public getColumnCount(): number {
+    return duckdb.init_get_column_count(this.init_info);
+  }
+  /** The index, among the bound result columns, of the given projected column. */
+  public getColumnIndex(columnIndex: number): number {
+    return duckdb.init_get_column_index(this.init_info, columnIndex);
+  }
+  /** All projected column indexes, in order. */
+  public getColumnIndexes(): number[] {
+    const count = this.getColumnCount();
+    const indexes: number[] = [];
+    for (let i = 0; i < count; i++) {
+      indexes.push(this.getColumnIndex(i));
+    }
+    return indexes;
+  }
+  public setInitData(initData: object) {
+    duckdb.init_set_init_data(this.init_info, initData);
+  }
+  public setMaxThreads(maxThreads: number) {
+    duckdb.init_set_max_threads(this.init_info, maxThreads);
+  }
+  public setError(error: string) {
+    duckdb.init_set_error(this.init_info, error);
+  }
+}

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

@@ -0,0 +1 @@
+export * from './types';

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

@@ -0,0 +1,46 @@
+// copy of duckdb_type, with names shortened
+export enum DuckDBTypeId {
+  INVALID = 0,
+  BOOLEAN = 1,
+  TINYINT = 2,
+  SMALLINT = 3,
+  INTEGER = 4,
+  BIGINT = 5,
+  UTINYINT = 6,
+  USMALLINT = 7,
+  UINTEGER = 8,
+  UBIGINT = 9,
+  FLOAT = 10,
+  DOUBLE = 11,
+  TIMESTAMP = 12,
+  DATE = 13,
+  TIME = 14,
+  INTERVAL = 15,
+  HUGEINT = 16,
+  UHUGEINT = 32,
+  VARCHAR = 17,
+  BLOB = 18,
+  DECIMAL = 19,
+  TIMESTAMP_S = 20,
+  TIMESTAMP_MS = 21,
+  TIMESTAMP_NS = 22,
+  ENUM = 23,
+  LIST = 24,
+  STRUCT = 25,
+  MAP = 26,
+  ARRAY = 33,
+  UUID = 27,
+  UNION = 28,
+  BIT = 29,
+  TIME_TZ = 30,
+  TIMESTAMP_TZ = 31,
+  ANY = 34,
+  BIGNUM = 35,
+  SQLNULL = 36,
+  STRING_LITERAL = 37,
+  INTEGER_LITERAL = 38,
+  TIME_NS = 39,
+  GEOMETRY = 40,
+  VARIANT = 41,
+  TIMESTAMP_TZ_NS = 42,
+}

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

@@ -0,0 +1,23 @@
+import { DuckDBType } from './DuckDBType';
+import { DuckDBValue } from './values';
+
+export type DuckDBValueConverter<T> = (
+  value: DuckDBValue,
+  type: DuckDBType,
+  converter: DuckDBValueConverter<T>
+) => T | null;
+
+/**
+ * A converter for a single DuckDB type id, whose output type is narrower than
+ * the output type of the top-level converter it recurses through.
+ *
+ * `DuckDBValueConverter<T>` ties both the return type and the recursion hook
+ * to the same `T`. In a per-type-id converter map, only the return type varies
+ * by id: the `converter` argument is always the map's top-level converter, so
+ * `Nested` stays fixed while `Out` narrows.
+ */
+export type DuckDBValueConverterFor<Out, Nested> = (
+  value: DuckDBValue,
+  type: DuckDBType,
+  converter: DuckDBValueConverter<Nested>
+) => Out | null;