@malloydata/db-duckdb 0.0.120-dev240131223846 → 0.0.120

package/dist/duckdb_common.d.ts

@@ -1,17 +1,16 @@
-import { MalloyQueryData, PersistSQLResults, PooledConnection, QueryDataRow, QueryRunStats, RunSQLOptions, SQLBlock, StreamingConnection, StructDef, TestableConnection, FetchSchemaOptions } from '@malloydata/malloy';
+import { FetchSchemaOptions, MalloyQueryData, PersistSQLResults, PooledConnection, QueryDataRow, QueryOptionsReader, QueryRunStats, RunSQLOptions, SQLBlock, StreamingConnection, StructDef, TestableConnection } from '@malloydata/malloy';
 export interface DuckDBQueryOptions {
     rowLimit: number;
 }
-export type QueryOptionsReader = Partial<DuckDBQueryOptions> | (() => Partial<DuckDBQueryOptions>);
 export declare abstract class DuckDBCommon implements TestableConnection, PersistSQLResults, StreamingConnection {
-    private queryOptions?;
+    protected queryOptions?: QueryOptionsReader | undefined;
     private readonly dialect;
     static DEFAULT_QUERY_OPTIONS: DuckDBQueryOptions;
     private schemaCache;
     private sqlSchemaCache;
     readonly name: string;
     get dialectName(): string;
-    private readQueryOptions;
+    protected readQueryOptions(): DuckDBQueryOptions;
     constructor(queryOptions?: QueryOptionsReader | undefined);
     isPool(): this is PooledConnection;
     canPersist(): this is PersistSQLResults;
@@ -25,7 +24,7 @@ export declare abstract class DuckDBCommon implements TestableConnection, Persis
         totalRows: number;
     }>;
     runSQL(sql: string, options?: RunSQLOptions): Promise<MalloyQueryData>;
-    abstract runSQLStream(sql: string, _options: RunSQLOptions): AsyncIterableIterator<QueryDataRow>;
+    abstract runSQLStream(sql: string, options: RunSQLOptions): AsyncIterableIterator<QueryDataRow>;
     private getSQLBlockSchema;
     estimateQueryCost(_: string): Promise<QueryRunStats>;
     /**

package/dist/duckdb_connection.d.ts

@@ -1,6 +1,11 @@
-import { DuckDBCommon, QueryOptionsReader } from './duckdb_common';
+import { DuckDBCommon } from './duckdb_common';
 import { Connection, Database, TableData } from 'duckdb';
-import { QueryDataRow, RunSQLOptions } from '@malloydata/malloy';
+import { ConnectionConfig, QueryDataRow, QueryOptionsReader, RunSQLOptions } from '@malloydata/malloy';
+export interface DuckDBConnectionOptions extends ConnectionConfig {
+    databasePath?: string;
+    workingDirectory?: string;
+    readOnly?: boolean;
+}
 interface ActiveDB {
     database: Database;
     connections: Connection[];
@@ -9,10 +14,12 @@ export declare class DuckDBConnection extends DuckDBCommon {
     readonly name: string;
     private databasePath;
     private workingDirectory;
+    private readOnly;
     connecting: Promise<void>;
     protected connection: Connection | null;
     protected isSetup: Promise<void> | undefined;
     static activeDBs: Record<string, ActiveDB>;
+    constructor(options: DuckDBConnectionOptions, queryOptions?: QueryOptionsReader);
     constructor(name: string, databasePath?: string, workingDirectory?: string, queryOptions?: QueryOptionsReader);
     private init;
     loadExtension(ext: string): Promise<void>;

package/dist/duckdb_connection.js

@@ -30,12 +30,42 @@ const crypto_1 = __importDefault(require("crypto"));
 const duckdb_common_1 = require("./duckdb_common");
 const duckdb_1 = require("duckdb");
 class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
-    constructor(name, databasePath = ':memory:', workingDirectory = '.', queryOptions) {
-        super(queryOptions);
-        this.name = name;
-        this.databasePath = databasePath;
-        this.workingDirectory = workingDirectory;
+    constructor(arg, arg2, workingDirectory, queryOptions) {
+        super();
+        this.databasePath = ':memory:';
+        this.workingDirectory = '.';
+        this.readOnly = false;
         this.connection = null;
+        if (typeof arg === 'string') {
+            this.name = arg;
+            if (typeof arg2 === 'string') {
+                this.databasePath = arg2;
+            }
+            if (typeof workingDirectory === 'string') {
+                this.workingDirectory = workingDirectory;
+            }
+            if (queryOptions) {
+                this.queryOptions = queryOptions;
+            }
+        }
+        else {
+            this.name = arg.name;
+            if (arg2) {
+                this.queryOptions = arg2;
+            }
+            if (typeof arg.readOnly === 'boolean') {
+                this.readOnly = arg.readOnly;
+            }
+            if (typeof arg.databasePath === 'string') {
+                this.databasePath = arg.databasePath;
+            }
+            if (typeof arg.workingDirectory === 'string') {
+                this.workingDirectory = arg.workingDirectory;
+            }
+        }
+        if (this.databasePath === ':memory:') {
+            this.readOnly = false;
+        }
         this.connecting = this.init();
     }
     async init() {
@@ -45,9 +75,7 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
                 activeDB = DuckDBConnection.activeDBs[this.databasePath];
             }
             else {
-                const database = new duckdb_1.Database(this.databasePath, duckdb_1.OPEN_READWRITE, // databasePath === ":memory:" ? OPEN_READWRITE : OPEN_READONLY,
-                // databasePath === ":memory:" ? OPEN_READWRITE : OPEN_READONLY,
-                err => {
+                const database = new duckdb_1.Database(this.databasePath, this.readOnly ? duckdb_1.OPEN_READONLY : duckdb_1.OPEN_READWRITE, err => {
                     if (err) {
                         reject(err);
                     }
@@ -125,6 +153,8 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
         });
     }
     async *runSQLStream(sql, { rowLimit, abortSignal } = {}) {
+        const defaultOptions = this.readQueryOptions();
+        rowLimit !== null && rowLimit !== void 0 ? rowLimit : (rowLimit = defaultOptions.rowLimit);
         await this.setup();
         if (!this.connection) {
             throw new Error('Connection not open');

package/dist/duckdb_wasm_connection.d.ts

@@ -1,8 +1,13 @@
 import * as duckdb from '@malloydata/duckdb-wasm';
-import { FetchSchemaOptions, QueryDataRow, RunSQLOptions, StructDef, SQLBlock } from '@malloydata/malloy';
-import { DuckDBCommon, QueryOptionsReader } from './duckdb_common';
+import { FetchSchemaOptions, QueryDataRow, QueryOptionsReader, RunSQLOptions, StructDef, SQLBlock, ConnectionConfig } from '@malloydata/malloy';
+import { DuckDBCommon } from './duckdb_common';
 type RemoteFileCallback = (tableName: string) => Promise<Uint8Array | undefined>;
+export interface DuckDBWasmOptions extends ConnectionConfig {
+    databasePath?: string;
+    workingDirectory?: string;
+}
 export declare abstract class DuckDBWASMConnection extends DuckDBCommon {
+    readonly arg: string | DuckDBWasmOptions;
     readonly name: string;
     private databasePath;
     protected workingDirectory: string;
@@ -13,6 +18,7 @@ export declare abstract class DuckDBWASMConnection extends DuckDBCommon {
     private worker;
     private remoteFileCallbacks;
     private remoteFileStatus;
+    constructor(options: DuckDBWasmOptions, queryOptions?: QueryOptionsReader);
     constructor(name: string, databasePath?: string | null, workingDirectory?: string, queryOptions?: QueryOptionsReader);
     private init;
     abstract getBundles(): duckdb.DuckDBBundles;

package/dist/duckdb_wasm_connection.js

@@ -121,16 +121,40 @@ const unwrapTable = (table) => {
 };
 const isNode = () => typeof navigator === 'undefined';
 class DuckDBWASMConnection extends duckdb_common_1.DuckDBCommon {
-    constructor(name, databasePath = null, workingDirectory = '/', queryOptions) {
-        super(queryOptions);
-        this.name = name;
-        this.databasePath = databasePath;
-        this.workingDirectory = workingDirectory;
+    constructor(arg, arg2, workingDirectory, queryOptions) {
+        super();
+        this.arg = arg;
+        this.databasePath = null;
+        this.workingDirectory = '/';
         this._connection = null;
         this._database = null;
         this.worker = null;
         this.remoteFileCallbacks = [];
         this.remoteFileStatus = {};
+        if (typeof arg === 'string') {
+            this.name = arg;
+            if (typeof arg2 === 'string') {
+                this.databasePath = arg2;
+            }
+            if (typeof workingDirectory === 'string') {
+                this.workingDirectory = workingDirectory;
+            }
+            if (queryOptions) {
+                this.queryOptions = queryOptions;
+            }
+        }
+        else {
+            this.name = arg.name;
+            if (arg2) {
+                this.queryOptions = arg2;
+            }
+            if (typeof arg.databasePath === 'string') {
+                this.databasePath = arg.databasePath;
+            }
+            if (typeof arg.workingDirectory === 'string') {
+                this.workingDirectory = arg.workingDirectory;
+            }
+        }
         this.connecting = this.init();
     }
     async init() {
@@ -230,6 +254,8 @@ class DuckDBWASMConnection extends duckdb_common_1.DuckDBCommon {
         if (!this.connection) {
             throw new Error('duckdb-wasm not connected');
         }
+        const defaultOptions = this.readQueryOptions();
+        rowLimit !== null && rowLimit !== void 0 ? rowLimit : (rowLimit = defaultOptions.rowLimit);
         await this.setup();
         const statements = sql.split('-- hack: split on this');
         let done = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-duckdb",
-  "version": "0.0.120-dev240131223846",
+  "version": "0.0.120",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -41,7 +41,7 @@
   },
   "dependencies": {
     "@malloydata/duckdb-wasm": "0.0.6",
-    "@malloydata/malloy": "^0.0.120-dev240131223846",
+    "@malloydata/malloy": "^0.0.120",
     "apache-arrow": "^13.0.0",
     "duckdb": "0.9.2",
     "web-worker": "^1.2.0"