@run-trace/duckdb-wasm 0.0.1

package/dist/types/bindings/runtime.d.ts

@@ -0,0 +1,99 @@
+import { DuckDBModule } from './duckdb_module';
+import { UDFFunction } from './udf_function';
+/** Helper to decode text */
+export declare const decodeText: (input?: BufferSource) => string;
+/** Copy a buffer */
+export declare function failWith(mod: DuckDBModule, msg: string): void;
+/** Copy a buffer */
+export declare function copyBuffer(mod: DuckDBModule, begin: number, length: number): Uint8Array;
+/** Decode a string */
+export declare function readString(mod: DuckDBModule, begin: number, length: number): string;
+/** The data protocol */
+export declare enum DuckDBDataProtocol {
+    BUFFER = 0,
+    NODE_FS = 1,
+    BROWSER_FILEREADER = 2,
+    BROWSER_FSACCESS = 3,
+    HTTP = 4,
+    S3 = 5
+}
+/** File flags for opening files*/
+export declare enum FileFlags {
+    FILE_FLAGS_READ = 1,
+    FILE_FLAGS_WRITE = 2,
+    FILE_FLAGS_DIRECT_IO = 4,
+    FILE_FLAGS_FILE_CREATE = 8,
+    FILE_FLAGS_FILE_CREATE_NEW = 16,
+    FILE_FLAGS_APPEND = 32,
+    FILE_FLAGS_PRIVATE = 64,
+    FILE_FLAGS_NULL_IF_NOT_EXISTS = 128,
+    FILE_FLAGS_PARALLEL_ACCESS = 256,
+    FILE_FLAGS_EXCLUSIVE_CREATE = 512,
+    FILE_FLAGS_NULL_IF_EXISTS = 1024
+}
+/** Configuration for the AWS S3 Filesystem */
+export interface S3Config {
+    region?: string;
+    endpoint?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    sessionToken?: string;
+}
+/** An info for a file registered with DuckDB */
+export interface DuckDBFileInfo {
+    cacheEpoch: number;
+    fileId: number;
+    fileName: string;
+    dataProtocol: DuckDBDataProtocol;
+    dataUrl: string | null;
+    reliableHeadRequests?: boolean;
+    allowFullHttpReads?: boolean;
+    forceFullHttpReads?: boolean;
+    s3Config?: S3Config;
+}
+/** Global info for all files registered with DuckDB */
+export interface DuckDBGlobalFileInfo {
+    cacheEpoch: number;
+    reliableHeadRequests?: boolean;
+    allowFullHttpReads?: boolean;
+    forceFullHttpReads?: boolean;
+    s3Config?: S3Config;
+}
+export interface PreparedDBFileHandle {
+    path: string;
+    handle: any;
+    fromCached: boolean;
+}
+/** Call a function with packed response buffer */
+export declare function callSRet(mod: DuckDBModule, funcName: string, argTypes: Array<Emscripten.JSType>, args: Array<any>): [number, number, number];
+/** Drop response buffers */
+export declare function dropResponseBuffers(mod: DuckDBModule): void;
+/** The duckdb runtime */
+export interface DuckDBRuntime {
+    _files?: Map<string, any>;
+    _udfFunctions: Map<number, UDFFunction>;
+    testPlatformFeature(mod: DuckDBModule, feature: number): boolean;
+    getDefaultDataProtocol(mod: DuckDBModule): number;
+    openFile(mod: DuckDBModule, fileId: number, flags: FileFlags): void;
+    syncFile(mod: DuckDBModule, fileId: number): void;
+    closeFile(mod: DuckDBModule, fileId: number): void;
+    dropFile(mod: DuckDBModule, fileNamePtr: number, fileNameLen: number): void;
+    getLastFileModificationTime(mod: DuckDBModule, fileId: number): number;
+    truncateFile(mod: DuckDBModule, fileId: number, newSize: number): void;
+    readFile(mod: DuckDBModule, fileId: number, buffer: number, bytes: number, location: number): number;
+    writeFile(mod: DuckDBModule, fileId: number, buffer: number, bytes: number, location: number): number;
+    removeDirectory(mod: DuckDBModule, pathPtr: number, pathLen: number): void;
+    checkDirectory(mod: DuckDBModule, pathPtr: number, pathLen: number): boolean;
+    createDirectory(mod: DuckDBModule, pathPtr: number, pathLen: number): void;
+    listDirectoryEntries(mod: DuckDBModule, pathPtr: number, pathLen: number): boolean;
+    glob(mod: DuckDBModule, pathPtr: number, pathLen: number): void;
+    moveFile(mod: DuckDBModule, fromPtr: number, fromLen: number, toPtr: number, toLen: number): void;
+    checkFile(mod: DuckDBModule, pathPtr: number, pathLen: number): boolean;
+    removeFile(mod: DuckDBModule, pathPtr: number, pathLen: number): void;
+    prepareFileHandle?: (path: string, protocol: DuckDBDataProtocol) => Promise<PreparedDBFileHandle[]>;
+    prepareFileHandles?: (path: string[], protocol: DuckDBDataProtocol) => Promise<PreparedDBFileHandle[]>;
+    prepareDBFileHandle?: (path: string, protocol: DuckDBDataProtocol) => Promise<PreparedDBFileHandle[]>;
+    progressUpdate(final: number, percentage: number, iteration: number): void;
+    callScalarUDF(mod: DuckDBModule, response: number, funcId: number, descPtr: number, descSize: number, ptrsPtr: number, ptrsSize: number): void;
+}
+export declare const DEFAULT_RUNTIME: DuckDBRuntime;

package/dist/types/bindings/runtime_browser.d.ts

@@ -0,0 +1,13 @@
+import { DuckDBFileInfo, DuckDBGlobalFileInfo, DuckDBRuntime } from './runtime';
+import { DuckDBModule } from './duckdb_module';
+export declare const BROWSER_RUNTIME: DuckDBRuntime & {
+    _files: Map<string, any>;
+    _fileInfoCache: Map<number, DuckDBFileInfo>;
+    _globalFileInfo: DuckDBGlobalFileInfo | null;
+    _preparedHandles: Record<string, FileSystemSyncAccessHandle>;
+    _opfsRoot: FileSystemDirectoryHandle | null;
+    getFileInfo(mod: DuckDBModule, fileId: number): DuckDBFileInfo | null;
+    getGlobalFileInfo(mod: DuckDBModule): DuckDBGlobalFileInfo | null;
+    assignOPFSRoot(): Promise<void>;
+};
+export default BROWSER_RUNTIME;

package/dist/types/bindings/runtime_node.d.ts

@@ -0,0 +1,8 @@
+import { DuckDBRuntime, DuckDBFileInfo } from './runtime';
+import { DuckDBModule } from './duckdb_module';
+export declare const NODE_RUNTIME: DuckDBRuntime & {
+    _filesById: Map<number, any>;
+    _fileInfoCache: Map<number, DuckDBFileInfo>;
+    resolveFileInfo(mod: DuckDBModule, fileId: number): DuckDBFileInfo | null;
+};
+export default NODE_RUNTIME;

package/dist/types/bindings/tokens.d.ts

@@ -0,0 +1,12 @@
+export declare enum TokenType {
+    IDENTIFIER = 0,
+    NUMERIC_CONSTANT = 1,
+    STRING_CONSTANT = 2,
+    OPERATOR = 3,
+    KEYWORD = 4,
+    COMMENT = 5
+}
+export interface ScriptTokens {
+    offsets: number[];
+    types: TokenType[];
+}

package/dist/types/bindings/udf_function.d.ts

@@ -0,0 +1,13 @@
+import { SQLType } from '../sql_field';
+export interface UDFFunctionDeclaration {
+    functionId: number;
+    name: string;
+    returnType: SQLType;
+}
+export interface UDFFunction {
+    functionId: number;
+    connectionId: number;
+    name: string;
+    returnType: SQLType;
+    func: (...args: any[]) => any;
+}

package/dist/types/bindings/udf_runtime.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBRuntime } from './runtime';
+import { DuckDBModule } from './duckdb_module';
+export declare function callScalarUDF(runtime: DuckDBRuntime, mod: DuckDBModule, response: number, funcId: number, descPtr: number, descSize: number, ptrsPtr: number, ptrsSize: number): void;

package/dist/types/bindings/web_file.d.ts

@@ -0,0 +1,12 @@
+import { DuckDBDataProtocol } from './runtime';
+export interface WebFile {
+    fileName: string;
+    dataProtocol: DuckDBDataProtocol;
+    fileId?: number;
+    fileSize?: number;
+    dataUrl?: string;
+    dataNativeFd?: number;
+    collectStatistics?: boolean;
+    reliableHeadRequests?: boolean;
+    allowFullHttpReads?: boolean;
+}

package/dist/types/duckdb.d.ts

@@ -0,0 +1,8 @@
+import { Logger } from './log.js';
+import { AsyncDuckDB } from './parallel/index.js';
+export interface DuckDBBundle {
+    mainModule: string;
+    mainWorker: string;
+    pthreadWorker?: string;
+}
+export declare function duckdb(config: DuckDBBundle, logger?: Logger): Promise<AsyncDuckDB>;

package/dist/types/index.d.ts

@@ -0,0 +1,11 @@
+export * from './bindings/config.js';
+export * from './bindings/tokens.js';
+export * from './log.js';
+export * from './status.js';
+export * from './parallel/index.js';
+export * from './platform.js';
+export * from './worker.js';
+export type { InstantiationProgress, InstantiationProgressHandler } from './bindings/progress.js';
+export type { DuckDBDataProtocol } from './bindings/runtime.js';
+export type { WebFile } from './bindings/web_file.js';
+export { duckdb } from './duckdb.js';

package/dist/types/log.d.ts

@@ -0,0 +1,61 @@
+export declare enum LogLevel {
+    NONE = 0,
+    DEBUG = 1,
+    INFO = 2,
+    WARNING = 3,
+    ERROR = 4
+}
+export declare enum LogTopic {
+    NONE = 0,
+    CONNECT = 1,
+    DISCONNECT = 2,
+    OPEN = 3,
+    QUERY = 4,
+    INSTANTIATE = 5
+}
+export declare enum LogEvent {
+    NONE = 0,
+    OK = 1,
+    ERROR = 2,
+    START = 3,
+    RUN = 4,
+    CAPTURE = 5
+}
+export declare enum LogOrigin {
+    NONE = 0,
+    WEB_WORKER = 1,
+    NODE_WORKER = 2,
+    BINDINGS = 3,
+    ASYNC_DUCKDB = 4
+}
+export type LogEntry<O, T, E, V> = {
+    readonly timestamp: Date;
+    readonly level: LogLevel;
+    readonly origin: O;
+    readonly topic: T;
+    readonly event: E;
+    readonly value: V;
+};
+export type ProgressEntry = {
+    readonly status: string;
+    readonly percentage: string;
+    readonly repetitions: string;
+};
+/** An execution progress handler */
+export type ExecutionProgressHandler = (p: ProgressEntry) => void;
+export type LogEntryVariant = LogEntry<LogOrigin.BINDINGS, LogTopic.INSTANTIATE, LogEvent.ERROR, string> | LogEntry<LogOrigin.BINDINGS, LogTopic.QUERY, LogEvent.START, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.QUERY, LogEvent.OK, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.QUERY, LogEvent.ERROR, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.CONNECT, LogEvent.OK, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.CONNECT, LogEvent.ERROR, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.DISCONNECT, LogEvent.OK, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.DISCONNECT, LogEvent.ERROR, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.OPEN, LogEvent.START, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.OPEN, LogEvent.OK, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.OPEN, LogEvent.ERROR, void> | LogEntry<LogOrigin.ASYNC_DUCKDB, LogTopic.QUERY, LogEvent.RUN, string>;
+export interface Logger {
+    log(entry: LogEntryVariant): void;
+}
+export declare class VoidLogger implements Logger {
+    log(_entry: LogEntryVariant): void;
+}
+export declare class ConsoleLogger implements Logger {
+    protected level: LogLevel;
+    constructor(level?: LogLevel);
+    log(entry: LogEntryVariant): void;
+}
+export declare function getLogLevelLabel(level: LogLevel): string;
+export declare function getLogEventLabel(event: LogEvent): string;
+export declare function getLogTopicLabel(topic: LogTopic): string;
+export declare function getLogOriginLabel(origin: LogOrigin): string;

package/dist/types/parallel/async_bindings.d.ts

@@ -0,0 +1,137 @@
+import { WorkerTaskVariant, ConnectionID, WorkerTaskReturnType } from './worker_request';
+import { AsyncDuckDBBindings } from './async_bindings_interface';
+import { Logger } from '../log';
+import { AsyncDuckDBConnection } from './async_connection';
+import { CSVInsertOptions, JSONInsertOptions, ArrowInsertOptions } from '../bindings/insert_options';
+import { ScriptTokens } from '../bindings/tokens';
+import { FileStatistics } from '../bindings/file_stats';
+import { DuckDBConfig } from '../bindings/config';
+import { InstantiationProgress } from '../bindings/progress';
+import { WebFile } from '../bindings/web_file';
+import { DuckDBDataProtocol } from '../bindings';
+import { ProgressEntry } from '../log';
+export declare class AsyncDuckDB implements AsyncDuckDBBindings {
+    /** The message handler */
+    protected readonly _onMessageHandler: (event: MessageEvent) => void;
+    /** The error handler */
+    protected readonly _onErrorHandler: (event: ErrorEvent) => void;
+    /** The close handler */
+    protected readonly _onCloseHandler: () => void;
+    /** Instantiate the module */
+    protected _onInstantiationProgress: ((p: InstantiationProgress) => void)[];
+    /** Progress callbacks */
+    protected _onExecutionProgress: ((p: ProgressEntry) => void)[];
+    /** The logger */
+    protected readonly _logger: Logger;
+    /** The worker */
+    protected _worker: Worker | null;
+    /** The promise for the worker shutdown */
+    protected _workerShutdownPromise: Promise<null> | null;
+    /** Make the worker as terminated */
+    protected _workerShutdownResolver: (value: PromiseLike<null> | null) => void;
+    /** The next message id */
+    protected _nextMessageId: number;
+    /** The pending requests */
+    protected _pendingRequests: Map<number, WorkerTaskVariant>;
+    /** The DuckDBConfig */
+    protected _config: DuckDBConfig;
+    constructor(logger: Logger, worker?: Worker | null);
+    /** Get the logger */
+    get logger(): Logger;
+    /** Get the logger */
+    get config(): DuckDBConfig;
+    /** Attach to worker */
+    protected attach(worker: Worker): void;
+    /** Detach from worker */
+    detach(): void;
+    /** Kill the worker */
+    terminate(): Promise<void>;
+    /** Post a task */
+    protected postTask<W extends WorkerTaskVariant>(task: W, transfer?: ArrayBuffer[]): Promise<WorkerTaskReturnType<W>>;
+    /** Received a message */
+    protected onMessage(event: MessageEvent): void;
+    /** Received an error */
+    protected onError(event: ErrorEvent): void;
+    /** The worker was closed */
+    protected onClose(): void;
+    /** Is in detached state, no worker defined */
+    isDetached(): boolean;
+    /** Reset the duckdb */
+    reset(): Promise<null>;
+    /** Ping the worker thread */
+    ping(): Promise<any>;
+    /** Try to drop a file */
+    dropFile(name: string): Promise<null>;
+    /** Try to drop files */
+    dropFiles(names?: string[]): Promise<null>;
+    /** Flush all files */
+    flushFiles(): Promise<null>;
+    /** Open the database */
+    instantiate(mainModuleURL: string, pthreadWorkerURL?: string | null, progress?: (progress: InstantiationProgress) => void): Promise<null>;
+    /** Get the version */
+    getVersion(): Promise<string>;
+    /** Get the feature flags */
+    getFeatureFlags(): Promise<number>;
+    /** Open a new database */
+    open(config: DuckDBConfig): Promise<void>;
+    /** Tokenize a script text */
+    tokenize(text: string): Promise<ScriptTokens>;
+    /** Connect to the database */
+    connectInternal(): Promise<number>;
+    /** Connect to the database */
+    connect(): Promise<AsyncDuckDBConnection>;
+    /** Disconnect from the database */
+    disconnect(conn: ConnectionID): Promise<void>;
+    /** Run a query */
+    runQuery(conn: ConnectionID, text: string): Promise<Uint8Array>;
+    private _runQueryAsync;
+    /** Start a pending query */
+    startPendingQuery(conn: ConnectionID, text: string, allowStreamResult?: boolean): Promise<Uint8Array | null>;
+    private _startPendingQueryAsync;
+    /** Poll a pending query */
+    pollPendingQuery(conn: ConnectionID): Promise<Uint8Array | null>;
+    /** Cancel a pending query */
+    cancelPendingQuery(conn: ConnectionID): Promise<boolean>;
+    /** Fetch query results */
+    fetchQueryResults(conn: ConnectionID): Promise<Uint8Array | null>;
+    /** Get table names */
+    getTableNames(conn: number, text: string): Promise<string[]>;
+    /** Prepare a statement and return its identifier */
+    createPrepared(conn: number, text: string): Promise<number>;
+    /** Close a prepared statement */
+    closePrepared(conn: number, statement: number): Promise<void>;
+    /** Execute a prepared statement and return the full result */
+    runPrepared(conn: number, statement: number, params: any[]): Promise<Uint8Array>;
+    /** Execute a prepared statement and stream the result */
+    sendPrepared(conn: number, statement: number, params: any[]): Promise<Uint8Array>;
+    /** Glob file infos */
+    globFiles(path: string): Promise<WebFile[]>;
+    /** Register file text */
+    registerFileText(name: string, text: string): Promise<void>;
+    /** Register a file path. */
+    registerFileURL(name: string, url: string, proto: DuckDBDataProtocol, directIO: boolean): Promise<void>;
+    /** Register an empty file buffer. */
+    registerEmptyFileBuffer(name: string): Promise<void>;
+    /** Register a file buffer. */
+    registerFileBuffer(name: string, buffer: Uint8Array): Promise<void>;
+    /** Register a file handle. */
+    registerFileHandle<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): Promise<void>;
+    /** Enable file statistics */
+    registerOPFSFileName(name: string): Promise<void>;
+    /** Enable file statistics */
+    collectFileStatistics(name: string, enable: boolean): Promise<void>;
+    /** Export file statistics */
+    exportFileStatistics(name: string): Promise<FileStatistics>;
+    /** Copy a file to a buffer. */
+    copyFileToBuffer(name: string): Promise<Uint8Array>;
+    /** Copy a file to a path. */
+    copyFileToPath(name: string, path: string): Promise<void>;
+    /** Insert arrow from an ipc stream */
+    insertArrowFromIPCStream(conn: ConnectionID, buffer: Uint8Array, options?: ArrowInsertOptions): Promise<void>;
+    /** Insert a csv file */
+    insertCSVFromPath(conn: ConnectionID, path: string, options: CSVInsertOptions): Promise<void>;
+    /** Insert a json file */
+    insertJSONFromPath(conn: ConnectionID, path: string, options: JSONInsertOptions): Promise<void>;
+    private shouldOPFSFileHandling;
+    private registerOPFSFileFromSQL;
+}

package/dist/types/parallel/async_bindings_interface.d.ts

@@ -0,0 +1,27 @@
+import { Logger } from '../log';
+import { ArrowInsertOptions, CSVInsertOptions, JSONInsertOptions } from '../bindings/insert_options';
+import { DuckDBDataProtocol } from '../bindings';
+/** An interface for the async DuckDB bindings */
+export interface AsyncDuckDBBindings {
+    logger: Logger;
+    registerFileURL(name: string, url: string, proto: DuckDBDataProtocol, directIO: boolean): Promise<void>;
+    registerFileBuffer(name: string, buffer: Uint8Array): Promise<void>;
+    registerFileHandle<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): Promise<void>;
+    copyFileToPath(name: string, out: string): Promise<void>;
+    copyFileToBuffer(name: string): Promise<Uint8Array>;
+    disconnect(conn: number): Promise<void>;
+    runQuery(conn: number, text: string): Promise<Uint8Array>;
+    startPendingQuery(conn: number, text: string, allowStreamResult: boolean): Promise<Uint8Array | null>;
+    pollPendingQuery(conn: number): Promise<Uint8Array | null>;
+    cancelPendingQuery(conn: number): Promise<boolean>;
+    fetchQueryResults(conn: number): Promise<Uint8Array | null>;
+    createPrepared(conn: number, text: string): Promise<number>;
+    closePrepared(conn: number, statement: number): Promise<void>;
+    runPrepared(conn: number, statement: number, params: any[]): Promise<Uint8Array>;
+    sendPrepared(conn: number, statement: number, params: any[]): Promise<Uint8Array>;
+    insertArrowFromIPCStream(conn: number, buffer: Uint8Array, options?: ArrowInsertOptions): Promise<void>;
+    insertCSVFromPath(conn: number, path: string, options: CSVInsertOptions): Promise<void>;
+    insertJSONFromPath(conn: number, path: string, options: JSONInsertOptions): Promise<void>;
+    dropFile(name: string): Promise<null>;
+    dropFiles(names?: string[]): Promise<null>;
+}

package/dist/types/parallel/async_connection.d.ts

@@ -0,0 +1,64 @@
+import { AsyncDuckDB } from './async_bindings';
+import { ArrowInsertOptions, CSVInsertOptions, JSONInsertOptions } from '../bindings/insert_options';
+/** A thin helper to memoize the connection id */
+export declare class AsyncDuckDBConnection {
+    /** The async duckdb */
+    protected readonly _bindings: AsyncDuckDB;
+    /** The conn handle */
+    protected readonly _conn: number;
+    constructor(bindings: AsyncDuckDB, conn: number);
+    /** Access the database bindings */
+    get bindings(): AsyncDuckDB;
+    /** Disconnect from the database */
+    close(): Promise<void>;
+    /** Brave souls may use this function to consume the underlying connection id */
+    useUnsafe<R>(callback: (bindings: AsyncDuckDB, conn: number) => R): R;
+    /** Run a query */
+    query(text: string): Promise<Uint8Array>;
+    /** Send a query */
+    send(text: string, allowStreamResult?: boolean): Promise<AsyncIterable<Uint8Array>>;
+    /** Cancel a query that was sent earlier */
+    cancelSent(): Promise<boolean>;
+    /** Get table names */
+    getTableNames(query: string): Promise<string[]>;
+    /** Create a prepared statement */
+    prepare(text: string): Promise<AsyncPreparedStatement>;
+    /** Insert an arrow table from an ipc stream */
+    insertArrowFromIPCStream(buffer: Uint8Array, options: ArrowInsertOptions): Promise<void>;
+    /** Insert csv file from path */
+    insertCSVFromPath(text: string, options: CSVInsertOptions): Promise<void>;
+    /** Insert json file from path */
+    insertJSONFromPath(text: string, options: JSONInsertOptions): Promise<void>;
+}
+/** An async result stream iterator */
+export declare class AsyncResultStreamIterator implements AsyncIterable<Uint8Array> {
+    protected readonly db: AsyncDuckDB;
+    protected readonly conn: number;
+    protected readonly header: Uint8Array;
+    /** First chunk? */
+    protected _first: boolean;
+    /** Reached end of stream? */
+    protected _depleted: boolean;
+    /** In-flight */
+    protected _inFlight: Promise<Uint8Array | null> | null;
+    constructor(db: AsyncDuckDB, conn: number, header: Uint8Array);
+    next(): Promise<IteratorResult<Uint8Array>>;
+    [Symbol.asyncIterator](): this;
+}
+/** A thin helper to bind the prepared statement id */
+export declare class AsyncPreparedStatement {
+    /** The bindings */
+    protected readonly bindings: AsyncDuckDB;
+    /** The connection id */
+    protected readonly connectionId: number;
+    /** The statement id */
+    protected readonly statementId: number;
+    /** Constructor */
+    constructor(bindings: AsyncDuckDB, connectionId: number, statementId: number);
+    /** Close a prepared statement */
+    close(): Promise<void>;
+    /** Run a prepared statement */
+    query(...params: any[]): Promise<Uint8Array>;
+    /** Send a prepared statement */
+    send(...params: any[]): Promise<AsyncIterable<Uint8Array>>;
+}

package/dist/types/parallel/index.d.ts

@@ -0,0 +1,5 @@
+export * from './async_connection.js';
+export * from './async_bindings_interface.js';
+export * from './async_bindings.js';
+export * from './worker_dispatcher.js';
+export * from './worker_request.js';

package/dist/types/parallel/worker_dispatcher.d.ts

@@ -0,0 +1,22 @@
+import { DuckDBBindings } from '../bindings';
+import { WorkerResponseVariant, WorkerRequestVariant } from './worker_request';
+import { Logger, LogEntryVariant } from '../log';
+import { InstantiationProgress } from '../bindings/progress';
+export declare abstract class AsyncDuckDBDispatcher implements Logger {
+    /** The bindings */
+    protected _bindings: DuckDBBindings | null;
+    /** The next message id */
+    protected _nextMessageId: number;
+    /** Instantiate the wasm module */
+    protected abstract instantiate(mainModule: string, pthreadWorker: string | null, progress: (p: InstantiationProgress) => void): Promise<DuckDBBindings>;
+    /** Post a response to the main thread */
+    protected abstract postMessage(response: WorkerResponseVariant, transfer: ArrayBuffer[]): void;
+    /** Send log entry to the main thread */
+    log(entry: LogEntryVariant): void;
+    /** Send plain OK without further data */
+    protected sendOK(request: WorkerRequestVariant): void;
+    /** Fail with an error */
+    protected failWith(request: WorkerRequestVariant, e: Error): void;
+    /** Process a request from the main thread */
+    onMessage(request: WorkerRequestVariant): Promise<void>;
+}

package/dist/types/parallel/worker_request.d.ts

@@ -0,0 +1,101 @@
+import { CSVInsertOptions, JSONInsertOptions, ArrowInsertOptions } from '../bindings/insert_options';
+import { LogEntryVariant, ProgressEntry } from '../log';
+import { ScriptTokens } from '../bindings/tokens';
+import { FileStatistics } from '../bindings/file_stats';
+import { DuckDBConfig } from '../bindings/config';
+import { WebFile } from '../bindings/web_file';
+import { InstantiationProgress } from '../bindings/progress';
+import { DuckDBDataProtocol } from '../bindings';
+export type ConnectionID = number;
+export type StatementID = number;
+export declare enum WorkerRequestType {
+    CANCEL_PENDING_QUERY = "CANCEL_PENDING_QUERY",
+    CLOSE_PREPARED = "CLOSE_PREPARED",
+    COLLECT_FILE_STATISTICS = "COLLECT_FILE_STATISTICS",
+    REGISTER_OPFS_FILE_NAME = "REGISTER_OPFS_FILE_NAME",
+    CONNECT = "CONNECT",
+    COPY_FILE_TO_BUFFER = "COPY_FILE_TO_BUFFER",
+    COPY_FILE_TO_PATH = "COPY_FILE_TO_PATH",
+    CREATE_PREPARED = "CREATE_PREPARED",
+    DISCONNECT = "DISCONNECT",
+    DROP_FILE = "DROP_FILE",
+    DROP_FILES = "DROP_FILES",
+    EXPORT_FILE_STATISTICS = "EXPORT_FILE_STATISTICS",
+    FETCH_QUERY_RESULTS = "FETCH_QUERY_RESULTS",
+    FLUSH_FILES = "FLUSH_FILES",
+    GET_FEATURE_FLAGS = "GET_FEATURE_FLAGS",
+    GET_TABLE_NAMES = "GET_TABLE_NAMES",
+    GET_VERSION = "GET_VERSION",
+    GLOB_FILE_INFOS = "GLOB_FILE_INFOS",
+    INSERT_ARROW_FROM_IPC_STREAM = "INSERT_ARROW_FROM_IPC_STREAM",
+    INSERT_CSV_FROM_PATH = "IMPORT_CSV_FROM_PATH",
+    INSERT_JSON_FROM_PATH = "IMPORT_JSON_FROM_PATH",
+    INSTANTIATE = "INSTANTIATE",
+    OPEN = "OPEN",
+    PING = "PING",
+    POLL_PENDING_QUERY = "POLL_PENDING_QUERY",
+    REGISTER_FILE_BUFFER = "REGISTER_FILE_BUFFER",
+    REGISTER_FILE_HANDLE = "REGISTER_FILE_HANDLE",
+    REGISTER_FILE_URL = "REGISTER_FILE_URL",
+    RESET = "RESET",
+    RUN_PREPARED = "RUN_PREPARED",
+    RUN_QUERY = "RUN_QUERY",
+    SEND_PREPARED = "SEND_PREPARED",
+    START_PENDING_QUERY = "START_PENDING_QUERY",
+    TOKENIZE = "TOKENIZE"
+}
+export declare enum WorkerResponseType {
+    CONNECTION_INFO = "CONNECTION_INFO",
+    ERROR = "ERROR",
+    FEATURE_FLAGS = "FEATURE_FLAGS",
+    FILE_BUFFER = "FILE_BUFFER",
+    FILE_INFOS = "FILE_INFOS",
+    FILE_SIZE = "FILE_SIZE",
+    FILE_STATISTICS = "FILE_STATISTICS",
+    INSTANTIATE_PROGRESS = "INSTANTIATE_PROGRESS",
+    LOG = "LOG",
+    PROGRESS_UPDATE = "PROGRESS_UPDATE",
+    OK = "OK",
+    PREPARED_STATEMENT_ID = "PREPARED_STATEMENT_ID",
+    QUERY_PLAN = "QUERY_PLAN",
+    QUERY_RESULT = "QUERY_RESULT",
+    QUERY_RESULT_CHUNK = "QUERY_RESULT_CHUNK",
+    QUERY_RESULT_HEADER = "QUERY_RESULT_HEADER",
+    QUERY_RESULT_HEADER_OR_NULL = "QUERY_RESULT_HEADER_OR_NULL",
+    REGISTERED_FILE = "REGISTERED_FILE",
+    SCRIPT_TOKENS = "SCRIPT_TOKENS",
+    SUCCESS = "SUCCESS",
+    TABLE_NAMES = "TABLE_NAMES",
+    VERSION_STRING = "VERSION_STRING"
+}
+export type WorkerRequest<T, P> = {
+    readonly messageId: number;
+    readonly type: T;
+    readonly data: P;
+};
+export type WorkerResponse<T, P> = {
+    readonly messageId: number;
+    readonly requestId: number;
+    readonly type: T;
+    readonly data: P;
+};
+export type WorkerTaskReturnType<T extends WorkerTaskVariant> = T extends WorkerTask<any, any, infer P> ? P : never;
+export declare class WorkerTask<T, D, P> {
+    readonly type: T;
+    readonly data: D;
+    promise: Promise<P>;
+    promiseResolver: (value: P | PromiseLike<P>) => void;
+    promiseRejecter: (value: any) => void;
+    constructor(type: T, data: D);
+}
+export type WorkerRequestVariant = WorkerRequest<WorkerRequestType.CLOSE_PREPARED, [ConnectionID, StatementID]> | WorkerRequest<WorkerRequestType.CANCEL_PENDING_QUERY, number> | WorkerRequest<WorkerRequestType.COLLECT_FILE_STATISTICS, [string, boolean]> | WorkerRequest<WorkerRequestType.REGISTER_OPFS_FILE_NAME, [string]> | WorkerRequest<WorkerRequestType.CONNECT, null> | WorkerRequest<WorkerRequestType.COPY_FILE_TO_BUFFER, string> | WorkerRequest<WorkerRequestType.COPY_FILE_TO_PATH, [string, string]> | WorkerRequest<WorkerRequestType.CREATE_PREPARED, [ConnectionID, string]> | WorkerRequest<WorkerRequestType.DISCONNECT, number> | WorkerRequest<WorkerRequestType.DROP_FILE, string> | WorkerRequest<WorkerRequestType.DROP_FILES, string[] | undefined> | WorkerRequest<WorkerRequestType.EXPORT_FILE_STATISTICS, string> | WorkerRequest<WorkerRequestType.FETCH_QUERY_RESULTS, number> | WorkerRequest<WorkerRequestType.FLUSH_FILES, null> | WorkerRequest<WorkerRequestType.GET_FEATURE_FLAGS, null> | WorkerRequest<WorkerRequestType.GET_TABLE_NAMES, [number, string]> | WorkerRequest<WorkerRequestType.GET_VERSION, null> | WorkerRequest<WorkerRequestType.GLOB_FILE_INFOS, string> | WorkerRequest<WorkerRequestType.INSERT_ARROW_FROM_IPC_STREAM, [
+    number,
+    Uint8Array,
+    ArrowInsertOptions | undefined
+]> | WorkerRequest<WorkerRequestType.INSERT_CSV_FROM_PATH, [number, string, CSVInsertOptions]> | WorkerRequest<WorkerRequestType.INSERT_JSON_FROM_PATH, [number, string, JSONInsertOptions]> | WorkerRequest<WorkerRequestType.INSTANTIATE, [string, string | null]> | WorkerRequest<WorkerRequestType.OPEN, DuckDBConfig> | WorkerRequest<WorkerRequestType.PING, null> | WorkerRequest<WorkerRequestType.POLL_PENDING_QUERY, number> | WorkerRequest<WorkerRequestType.REGISTER_FILE_BUFFER, [string, Uint8Array]> | WorkerRequest<WorkerRequestType.REGISTER_FILE_HANDLE, [string, any, DuckDBDataProtocol, boolean]> | WorkerRequest<WorkerRequestType.REGISTER_FILE_URL, [string, string, DuckDBDataProtocol, boolean]> | WorkerRequest<WorkerRequestType.RESET, null> | WorkerRequest<WorkerRequestType.RUN_PREPARED, [number, number, any[]]> | WorkerRequest<WorkerRequestType.RUN_QUERY, [number, string]> | WorkerRequest<WorkerRequestType.SEND_PREPARED, [number, number, any[]]> | WorkerRequest<WorkerRequestType.START_PENDING_QUERY, [number, string, boolean]> | WorkerRequest<WorkerRequestType.TOKENIZE, string>;
+export type WorkerResponseVariant = WorkerResponse<WorkerResponseType.CONNECTION_INFO, number> | WorkerResponse<WorkerResponseType.ERROR, any> | WorkerResponse<WorkerResponseType.FEATURE_FLAGS, number> | WorkerResponse<WorkerResponseType.FILE_BUFFER, Uint8Array> | WorkerResponse<WorkerResponseType.FILE_INFOS, WebFile[]> | WorkerResponse<WorkerResponseType.FILE_SIZE, number> | WorkerResponse<WorkerResponseType.FILE_STATISTICS, FileStatistics> | WorkerResponse<WorkerResponseType.INSTANTIATE_PROGRESS, InstantiationProgress> | WorkerResponse<WorkerResponseType.LOG, LogEntryVariant> | WorkerResponse<WorkerResponseType.PROGRESS_UPDATE, ProgressEntry> | WorkerResponse<WorkerResponseType.OK, null> | WorkerResponse<WorkerResponseType.PREPARED_STATEMENT_ID, number> | WorkerResponse<WorkerResponseType.QUERY_PLAN, Uint8Array> | WorkerResponse<WorkerResponseType.QUERY_RESULT, Uint8Array> | WorkerResponse<WorkerResponseType.QUERY_RESULT_CHUNK, Uint8Array | null> | WorkerResponse<WorkerResponseType.QUERY_RESULT_HEADER, Uint8Array> | WorkerResponse<WorkerResponseType.QUERY_RESULT_HEADER_OR_NULL, Uint8Array | null> | WorkerResponse<WorkerResponseType.SCRIPT_TOKENS, ScriptTokens> | WorkerResponse<WorkerResponseType.SUCCESS, boolean> | WorkerResponse<WorkerResponseType.TABLE_NAMES, string[]> | WorkerResponse<WorkerResponseType.VERSION_STRING, string>;
+export type WorkerTaskVariant = WorkerTask<WorkerRequestType.COLLECT_FILE_STATISTICS, [string, boolean], null> | WorkerTask<WorkerRequestType.REGISTER_OPFS_FILE_NAME, [string], null> | WorkerTask<WorkerRequestType.CLOSE_PREPARED, [number, number], null> | WorkerTask<WorkerRequestType.CONNECT, null, ConnectionID> | WorkerTask<WorkerRequestType.COPY_FILE_TO_BUFFER, string, Uint8Array> | WorkerTask<WorkerRequestType.COPY_FILE_TO_PATH, [string, string], null> | WorkerTask<WorkerRequestType.CREATE_PREPARED, [number, string], number> | WorkerTask<WorkerRequestType.DISCONNECT, ConnectionID, null> | WorkerTask<WorkerRequestType.DROP_FILE, string, null> | WorkerTask<WorkerRequestType.DROP_FILES, string[] | undefined, null> | WorkerTask<WorkerRequestType.EXPORT_FILE_STATISTICS, string, FileStatistics> | WorkerTask<WorkerRequestType.FETCH_QUERY_RESULTS, ConnectionID, Uint8Array | null> | WorkerTask<WorkerRequestType.FLUSH_FILES, null, null> | WorkerTask<WorkerRequestType.GET_FEATURE_FLAGS, null, number> | WorkerTask<WorkerRequestType.GET_TABLE_NAMES, [number, string], string[]> | WorkerTask<WorkerRequestType.GET_VERSION, null, string> | WorkerTask<WorkerRequestType.INSERT_ARROW_FROM_IPC_STREAM, [
+    number,
+    Uint8Array,
+    ArrowInsertOptions | undefined
+], null> | WorkerTask<WorkerRequestType.INSERT_CSV_FROM_PATH, [number, string, CSVInsertOptions], null> | WorkerTask<WorkerRequestType.INSERT_JSON_FROM_PATH, [number, string, JSONInsertOptions], null> | WorkerTask<WorkerRequestType.INSTANTIATE, [string, string | null], null> | WorkerTask<WorkerRequestType.OPEN, DuckDBConfig, null> | WorkerTask<WorkerRequestType.PING, null, null> | WorkerTask<WorkerRequestType.REGISTER_FILE_BUFFER, [string, Uint8Array], null> | WorkerTask<WorkerRequestType.REGISTER_FILE_HANDLE, [string, any, DuckDBDataProtocol, boolean], null> | WorkerTask<WorkerRequestType.REGISTER_FILE_URL, [string, string, DuckDBDataProtocol, boolean], null> | WorkerTask<WorkerRequestType.GLOB_FILE_INFOS, string, WebFile[]> | WorkerTask<WorkerRequestType.RESET, null, null> | WorkerTask<WorkerRequestType.RUN_PREPARED, [number, number, any[]], Uint8Array> | WorkerTask<WorkerRequestType.RUN_QUERY, [ConnectionID, string], Uint8Array> | WorkerTask<WorkerRequestType.SEND_PREPARED, [number, number, any[]], Uint8Array> | WorkerTask<WorkerRequestType.START_PENDING_QUERY, [ConnectionID, string, boolean], Uint8Array | null> | WorkerTask<WorkerRequestType.POLL_PENDING_QUERY, ConnectionID, Uint8Array | null> | WorkerTask<WorkerRequestType.CANCEL_PENDING_QUERY, ConnectionID, boolean> | WorkerTask<WorkerRequestType.TOKENIZE, string, ScriptTokens>;