@duckdb/duckdb-wasm 1.11.0 → 1.11.1-dev.0

package/dist/types/src/bindings/bindings_base.d.ts

@@ -1,13 +1,15 @@
 import { DuckDBModule, PThread } from './duckdb_module';
 import { DuckDBConfig } from './config';
 import { Logger } from '../log';
+import { InstantiationProgress } from './progress';
 import { DuckDBBindings } from './bindings_interface';
 import { DuckDBConnection } from './connection';
-import { DuckDBRuntime } from './runtime';
+import { DuckDBRuntime, DuckDBDataProtocol } from './runtime';
 import { CSVInsertOptions, JSONInsertOptions, ArrowInsertOptions } from './insert_options';
 import { ScriptTokens } from './tokens';
 import { FileStatistics } from './file_stats';
 import { WebFile } from './web_file';
+import * as arrow from 'apache-arrow';
 declare global {
     var DUCKDB_RUNTIME: any;
 }
@@ -31,6 +33,8 @@ export declare abstract class DuckDBBindingsBase implements DuckDBBindings {
     protected _initPromise: Promise<void> | null;
     /** The resolver for the open promise (called by onRuntimeInitialized) */
     protected _initPromiseResolver: () => void;
+    /** The next UDF id */
+    protected _nextUDFId: number;
     constructor(logger: Logger, runtime: DuckDBRuntime);
     /** Get the logger */
     get logger(): Logger;
@@ -40,9 +44,11 @@ export declare abstract class DuckDBBindingsBase implements DuckDBBindings {
     get pthread(): PThread | null;
     /** Instantiate the module */
     protected abstract instantiateImpl(moduleOverrides: Partial<DuckDBModule>): Promise<DuckDBModule>;
+    /** Instantiate the module */
+    protected onInstantiationProgress: ((p: InstantiationProgress) => void)[];
     /** Instantiate the database */
-    instantiate(): Promise<this>;
-    /** Open a database at a path */
+    instantiate(onProgress?: (progress: InstantiationProgress) => void): Promise<this>;
+    /** Open a database with a config */
     open(config: DuckDBConfig): void;
     /** Reset the database */
     reset(): void;
@@ -58,10 +64,23 @@ export declare abstract class DuckDBBindingsBase implements DuckDBBindings {
     disconnect(conn: number): void;
     /** Send a query and return the full result */
     runQuery(conn: number, text: string): Uint8Array;
-    /** Send a query asynchronously. Results have to be fetched with `fetchQueryResults` */
-    sendQuery(conn: number, text: string): Uint8Array;
+    /**
+     *  Start a pending query asynchronously.
+     *  This method returns either the arrow ipc schema or null.
+     *  On null, the query has to be executed using `pollPendingQuery` until that returns != null.
+     *  Results can then be fetched using `fetchQueryResults`
+     */
+    startPendingQuery(conn: number, text: string): Uint8Array | null;
+    /** Poll a pending query */
+    pollPendingQuery(conn: number): Uint8Array | null;
+    /** Cancel a pending query */
+    cancelPendingQuery(conn: number): boolean;
     /** Fetch query results */
     fetchQueryResults(conn: number): Uint8Array;
+    /** Get table names */
+    getTableNames(conn: number, text: string): string[];
+    /** Create a scalar function */
+    createScalarFunction(conn: number, name: string, returns: arrow.DataType, func: (...args: any[]) => void): void;
     /** Prepare a statement and return its identifier */
     createPrepared(conn: number, text: string): number;
     /** Close a prepared statement */
@@ -79,15 +98,15 @@ export declare abstract class DuckDBBindingsBase implements DuckDBBindings {
     /** Glob file infos */
     globFiles(path: string): WebFile[];
     /** Register a file object URL */
-    registerFileURL(name: string, url?: string): void;
+    registerFileURL(name: string, url: string, proto: DuckDBDataProtocol, directIO?: boolean): void;
     /** Register file text */
     registerFileText(name: string, text: string): void;
     /** Register a file buffer */
     registerFileBuffer(name: string, buffer: Uint8Array): void;
     /** Register a file object URL */
-    registerFileHandle<HandleType>(name: string, handle: HandleType): void;
+    registerFileHandle<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): void;
     /** Drop file */
-    dropFile(name: string): boolean;
+    dropFile(name: string): void;
     /** Drop files */
     dropFiles(): void;
     /** Flush all files */

package/dist/types/src/bindings/bindings_interface.d.ts

@@ -1,31 +1,37 @@
-import { DuckDBConfig, DuckDBConnection, FileStatistics } from '.';
+import { DuckDBConfig, DuckDBConnection, DuckDBDataProtocol, FileStatistics, InstantiationProgress } from '.';
 import { CSVInsertOptions, JSONInsertOptions, ArrowInsertOptions } from './insert_options';
 import { ScriptTokens } from './tokens';
 import { WebFile } from './web_file';
+import * as arrow from 'apache-arrow';
 export interface DuckDBBindings {
     open(config: DuckDBConfig): void;
     reset(): void;
+    instantiate(onProgress: (p: InstantiationProgress) => void): Promise<this>;
     getVersion(): string;
     getFeatureFlags(): number;
     tokenize(text: string): ScriptTokens;
     connect(): DuckDBConnection;
     disconnect(conn: number): void;
     runQuery(conn: number, text: string): Uint8Array;
-    sendQuery(conn: number, text: string): Uint8Array;
+    startPendingQuery(conn: number, text: string): Uint8Array | null;
+    pollPendingQuery(conn: number): Uint8Array | null;
+    cancelPendingQuery(conn: number): boolean;
     fetchQueryResults(conn: number): Uint8Array;
+    getTableNames(conn: number, text: string): string[];
     createPrepared(conn: number, text: string): number;
     closePrepared(conn: number, statement: number): void;
     runPrepared(conn: number, statement: number, params: any[]): Uint8Array;
     sendPrepared(conn: number, statement: number, params: any[]): Uint8Array;
+    createScalarFunction(conn: number, name: string, returns: arrow.DataType, func: (...args: any[]) => void): void;
     insertArrowFromIPCStream(conn: number, buffer: Uint8Array, options?: ArrowInsertOptions): void;
     insertCSVFromPath(conn: number, path: string, options: CSVInsertOptions): void;
     insertJSONFromPath(conn: number, path: string, options: JSONInsertOptions): void;
-    registerFileURL(name: string, url?: string): void;
+    registerFileURL(name: string, url: string, proto: DuckDBDataProtocol, directIO: boolean): void;
     registerFileText(name: string, text: string): void;
     registerFileBuffer(name: string, buffer: Uint8Array): void;
-    registerFileHandle<HandleType>(name: string, handle: HandleType): void;
+    registerFileHandle<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): void;
     globFiles(path: string): WebFile[];
-    dropFile(name: string): boolean;
+    dropFile(name: string): void;
     dropFiles(): void;
     flushFiles(): void;
     copyFileToPath(name: string, path: string): void;

package/dist/types/src/bindings/config.d.ts

@@ -1,20 +1,47 @@
-/** A DuckDB Config */
+export interface DuckDBQueryConfig {
+    /**
+     * The polling interval for queries
+     */
+    queryPollingInterval?: number;
+    /**
+     * Cast BigInt to Double?
+     */
+    castBigIntToDouble?: boolean;
+    /**
+     * Cast Timestamp to Date64?
+     */
+    castTimestampToDate?: boolean;
+    /**
+     * Cast Timestamp to Date64?
+     */
+    castDurationToTime64?: boolean;
+    /**
+     * Cast Decimal to Double?
+     */
+    castDecimalToDouble?: boolean;
+}
+export interface DuckDBFilesystemConfig {
+    /**
+     * Allow falling back to full HTTP reads if the server does not support range requests.
+     */
+    allowFullHTTPReads?: boolean;
+}
 export interface DuckDBConfig {
     /**
      * The database path
      */
     path?: string;
-    /**
-     * Emit BigInts?
-     */
-    emitBigInt?: boolean;
     /**
      * The maximum number of threads.
      * Note that this will only work with cross-origin isolated sites since it requires SharedArrayBuffers.
      */
     maximumThreads?: number;
     /**
-     * Allow falling back to full HTTP reads if the server does not support range requests.
+     * The query config
      */
-    allowFullHTTPReads?: boolean;
+    query?: DuckDBQueryConfig;
+    /**
+     * The filesystem config
+     */
+    filesystem?: DuckDBFilesystemConfig;
 }

package/dist/types/src/bindings/connection.d.ts

@@ -20,11 +20,17 @@ export declare class DuckDBConnection {
     /** Send a query */
     send<T extends {
         [key: string]: arrow.DataType;
-    } = any>(text: string): arrow.RecordBatchStreamReader<T>;
+    } = any>(text: string): Promise<arrow.RecordBatchStreamReader<T>>;
+    /** Cancel a query that was sent earlier */
+    cancelSent(): boolean;
+    /** Get table names */
+    getTableNames(query: string): string[];
     /** Create a prepared statement */
     prepare<T extends {
         [key: string]: arrow.DataType;
     } = any>(text: string): PreparedStatement;
+    /** Create a scalar function */
+    createScalarFunction(name: string, returns: arrow.DataType, func: (...args: any[]) => void): void;
     /** Insert an arrow table */
     insertArrowTable(table: arrow.Table, options: ArrowInsertOptions): void;
     /** Insert an arrow table from an ipc stream */

package/dist/types/src/bindings/index.d.ts

@@ -6,4 +6,4 @@ export * from './duckdb_module';
 export * from './file_stats';
 export * from './runtime';
 export * from './insert_options';
-export * from './insert';
+export * from './progress';

package/dist/types/src/bindings/insert_options.d.ts

@@ -1,5 +1,5 @@
 import * as arrow from 'apache-arrow';
-import { FlatArrowField } from '../flat_arrow';
+import { SQLField } from '../json_typedef';
 export declare enum JSONTableShape {
     ROW_ARRAY = "row-array",
     COLUMN_OBJECT = "column-object"
@@ -12,7 +12,7 @@ export interface JSONInsertOptions {
     columns?: {
         [key: string]: arrow.DataType;
     };
-    columnsFlat?: FlatArrowField[];
+    columnsFlat?: SQLField[];
 }
 export interface CSVInsertOptions {
     name: string;
@@ -29,7 +29,7 @@ export interface CSVInsertOptions {
     columns?: {
         [key: string]: arrow.DataType;
     };
-    columnsFlat?: FlatArrowField[];
+    columnsFlat?: SQLField[];
 }
 export interface ArrowInsertOptions {
     name: string;

package/dist/types/src/bindings/progress.d.ts

@@ -0,0 +1,9 @@
+/** An instantiation progress */
+export interface InstantiationProgress {
+    startedAt: Date;
+    updatedAt: Date;
+    bytesTotal: number;
+    bytesLoaded: number;
+}
+/** An instantiation progress handler */
+export declare type InstantiationProgressHandler = (p: InstantiationProgress) => void;

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

@@ -1,7 +1,8 @@
 /// <reference types="emscripten" />
 import { DuckDBModule } from './duckdb_module';
+import { UDFFunction } from './udf_function';
 /** Helper to decode text */
-export declare const decodeText: (input?: BufferSource | undefined) => string;
+export declare const decodeText: (input?: BufferSource) => string;
 /** Copy a buffer */
 export declare function failWith(mod: DuckDBModule, msg: string): void;
 /** Copy a buffer */
@@ -11,17 +12,44 @@ export declare function readString(mod: DuckDBModule, begin: number, length: num
 /** The data protocol */
 export declare enum DuckDBDataProtocol {
     BUFFER = 0,
-    NATIVE = 1,
-    HTTP = 3
+    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
+}
+/** 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;
-    dataNativeFd: number | null;
     allowFullHttpReads?: boolean;
+    s3Config?: S3Config;
+}
+/** Global info for all files registered with DuckDB */
+export interface DuckDBGlobalFileInfo {
+    cacheEpoch: number;
+    allowFullHttpReads?: boolean;
+    s3Config?: S3Config;
 }
 /** 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];
@@ -30,8 +58,10 @@ 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;
-    openFile(mod: DuckDBModule, fileId: number): void;
+    getDefaultDataProtocol(mod: DuckDBModule): number;
+    openFile(mod: DuckDBModule, fileId: number, flags: FileFlags): void;
     syncFile(mod: DuckDBModule, fileId: number): void;
     closeFile(mod: DuckDBModule, fileId: number): void;
     getLastFileModificationTime(mod: DuckDBModule, fileId: number): number;
@@ -46,5 +76,6 @@ export interface DuckDBRuntime {
     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;
+    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/src/bindings/runtime_browser.d.ts

@@ -1,7 +1,9 @@
-import { DuckDBRuntime, DuckDBFileInfo } from './runtime';
+import { DuckDBFileInfo, DuckDBGlobalFileInfo, DuckDBRuntime } from './runtime';
 import { DuckDBModule } from './duckdb_module';
 export declare const BROWSER_RUNTIME: DuckDBRuntime & {
-    fileInfoCache: Map<number, DuckDBFileInfo>;
+    _fileInfoCache: Map<number, DuckDBFileInfo>;
+    _globalFileInfo: DuckDBGlobalFileInfo | null;
     getFileInfo(mod: DuckDBModule, fileId: number): DuckDBFileInfo | null;
+    getGlobalFileInfo(mod: DuckDBModule): DuckDBGlobalFileInfo | null;
 };
 export default BROWSER_RUNTIME;

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

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

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

@@ -0,0 +1,14 @@
+import { SQLType } from '../json_typedef';
+import * as arrow from 'apache-arrow';
+export interface UDFFunctionDeclaration {
+    functionId: number;
+    name: string;
+    returnType: SQLType;
+}
+export interface UDFFunction {
+    functionId: number;
+    connectionId: number;
+    name: string;
+    returnType: arrow.DataType;
+    func: (...args: any[]) => any;
+}

package/dist/types/src/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/src/bindings/web_file.d.ts

@@ -1,14 +1,11 @@
-export declare enum DataProtocol {
-    BUFFER = 0,
-    NATIVE = 1,
-    HTTP = 2
-}
+import { DuckDBDataProtocol } from './runtime';
 export interface WebFile {
     fileName: string;
-    dataProtocol: DataProtocol;
+    dataProtocol: DuckDBDataProtocol;
     fileId?: number;
     fileSize?: number;
     dataUrl?: string;
     dataNativeFd?: number;
+    collectStatistics?: boolean;
     allowFullHttpReads?: boolean;
 }

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

@@ -4,3 +4,4 @@ export * from './parallel';
 export * from './status';
 export * from './platform';
 export * from './version';
+export * from './worker';

package/dist/types/src/json_typedef.d.ts

@@ -0,0 +1,17 @@
+import * as arrow from 'apache-arrow';
+export interface SQLType {
+    sqlType: string;
+    nullable?: boolean;
+    precision?: number;
+    scale?: number;
+    timezone?: string;
+    byteWidth?: number;
+    keyType?: SQLType;
+    valueType?: SQLType;
+    fields?: SQLField[];
+}
+export declare function arrowToSQLType(type: arrow.DataType): SQLType;
+export declare type SQLField = SQLType & {
+    name: string;
+};
+export declare function arrowToSQLField(name: string, type: arrow.DataType): SQLField;

package/dist/types/src/log.d.ts

@@ -10,7 +10,8 @@ export declare enum LogTopic {
     CONNECT = 1,
     DISCONNECT = 2,
     OPEN = 3,
-    QUERY = 4
+    QUERY = 4,
+    INSTANTIATE = 5
 }
 export declare enum LogEvent {
     NONE = 0,
@@ -35,7 +36,7 @@ export declare type LogEntry<O, T, E, V> = {
     readonly event: E;
     readonly value: V;
 };
-export declare type LogEntryVariant = 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 declare 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;
 }
@@ -43,6 +44,8 @@ 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;

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

@@ -6,7 +6,9 @@ import { CSVInsertOptions, JSONInsertOptions, ArrowInsertOptions } from '../bind
 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';
 export declare class AsyncDuckDB implements AsyncDuckDBBindings {
     /** The message handler */
     protected readonly _onMessageHandler: (event: MessageEvent) => void;
@@ -14,6 +16,8 @@ export declare class AsyncDuckDB implements AsyncDuckDBBindings {
     protected readonly _onErrorHandler: (event: ErrorEvent) => void;
     /** The close handler */
     protected readonly _onCloseHandler: () => void;
+    /** Instantiate the module */
+    protected _onInstantiationProgress: ((p: InstantiationProgress) => void)[];
     /** The logger */
     protected readonly _logger: Logger;
     /** The worker */
@@ -48,13 +52,13 @@ export declare class AsyncDuckDB implements AsyncDuckDBBindings {
     /** Ping the worker thread */
     ping(): Promise<any>;
     /** Try to drop a file */
-    dropFile(name: string): Promise<boolean>;
+    dropFile(name: string): Promise<null>;
     /** Try to drop files */
     dropFiles(): Promise<null>;
     /** Flush all files */
     flushFiles(): Promise<null>;
     /** Open the database */
-    instantiate(mainModuleURL: string, pthreadWorkerURL?: string | null): Promise<null>;
+    instantiate(mainModuleURL: string, pthreadWorkerURL?: string | null, progress?: (progress: InstantiationProgress) => void): Promise<null>;
     /** Get the version */
     getVersion(): Promise<string>;
     /** Get the feature flags */
@@ -71,10 +75,16 @@ export declare class AsyncDuckDB implements AsyncDuckDBBindings {
     disconnect(conn: ConnectionID): Promise<void>;
     /** Run a query */
     runQuery(conn: ConnectionID, text: string): Promise<Uint8Array>;
-    /** Send a query */
-    sendQuery(conn: ConnectionID, text: string): Promise<Uint8Array>;
+    /** Start a pending query */
+    startPendingQuery(conn: ConnectionID, text: string): Promise<Uint8Array | null>;
+    /** 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>;
+    /** 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 */
@@ -88,13 +98,13 @@ export declare class AsyncDuckDB implements AsyncDuckDBBindings {
     /** Register file text */
     registerFileText(name: string, text: string): Promise<void>;
     /** Register a file path. */
-    registerFileURL(name: string, url: string): Promise<void>;
+    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): Promise<void>;
+    registerFileHandle<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): Promise<void>;
     /** Enable file statistics */
     collectFileStatistics(name: string, enable: boolean): Promise<void>;
     /** Export file statistics */

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

@@ -1,16 +1,19 @@
 import { Logger } from '../log';
 import { 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, size: number): Promise<void>;
+    registerFileURL(name: string, url: string, proto: DuckDBDataProtocol, directIO: boolean): Promise<void>;
     registerFileBuffer(name: string, buffer: Uint8Array): Promise<void>;
-    registerFileHandle<HandleType>(name: string, handle: HandleType): 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>;
-    sendQuery(conn: number, text: string): Promise<Uint8Array>;
+    startPendingQuery(conn: number, text: string): Promise<Uint8Array | null>;
+    pollPendingQuery(conn: number): Promise<Uint8Array | null>;
+    cancelPendingQuery(conn: number): Promise<boolean>;
     fetchQueryResults(conn: number): Promise<Uint8Array>;
     createPrepared(conn: number, text: string): Promise<number>;
     closePrepared(conn: number, statement: number): Promise<void>;

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

@@ -22,6 +22,10 @@ export declare class AsyncDuckDBConnection {
     send<T extends {
         [key: string]: arrow.DataType;
     } = any>(text: string): Promise<arrow.AsyncRecordBatchStreamReader<T>>;
+    /** Cancel a query that was sent earlier */
+    cancelSent(): Promise<boolean>;
+    /** Get table names */
+    getTableNames(query: string): Promise<string[]>;
     /** Create a prepared statement */
     prepare<T extends {
         [key: string]: arrow.DataType;

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

@@ -1,13 +1,14 @@
 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): Promise<DuckDBBindings>;
+    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 */