@malloydata/db-duckdb 0.0.120-dev240125201336 → 0.0.120-dev240131220338

package/dist/duckdb.spec.js

@@ -32,51 +32,72 @@ const duckdb_connection_1 = require("./duckdb_connection");
  */
 describe('DuckDBConnection', () => {
     let connection;
-    let runRawSQL;
     beforeAll(async () => {
         connection = new duckdb_connection_1.DuckDBConnection('duckdb');
         await connection.runSQL('SELECT 1');
+        expect(Object.keys(duckdb_connection_1.DuckDBConnection.activeDBs).length).toEqual(1);
     });
     afterAll(async () => {
         await connection.close();
+        expect(Object.keys(duckdb_connection_1.DuckDBConnection.activeDBs).length).toEqual(0);
     });
-    beforeEach(async () => {
-        runRawSQL = jest
-            .spyOn(duckdb_common_1.DuckDBCommon.prototype, 'runRawSQL')
-            .mockResolvedValue({ rows: [], totalRows: 0 });
-    });
-    afterEach(() => {
-        jest.resetAllMocks();
-    });
-    it('caches table schema', async () => {
-        await connection.fetchSchemaForTables({ 'test1': 'table1' }, {});
-        expect(runRawSQL).toBeCalledTimes(1);
-        await new Promise(resolve => setTimeout(resolve));
-        await connection.fetchSchemaForTables({ 'test1': 'table1' }, {});
-        expect(runRawSQL).toBeCalledTimes(1);
-    });
-    it('refreshes table schema', async () => {
-        await connection.fetchSchemaForTables({ 'test2': 'table2' }, {});
-        expect(runRawSQL).toBeCalledTimes(1);
-        await new Promise(resolve => setTimeout(resolve));
-        await connection.fetchSchemaForTables({ 'test2': 'table2' }, { refreshTimestamp: Date.now() + 10 });
-        expect(runRawSQL).toBeCalledTimes(2);
-    });
-    it('caches sql schema', async () => {
-        await connection.fetchSchemaForSQLBlock(SQL_BLOCK_1, {});
-        expect(runRawSQL).toBeCalledTimes(1);
-        await new Promise(resolve => setTimeout(resolve));
-        await connection.fetchSchemaForSQLBlock(SQL_BLOCK_1, {});
-        expect(runRawSQL).toBeCalledTimes(1);
+    describe('schema', () => {
+        let runRawSQL;
+        beforeEach(async () => {
+            runRawSQL = jest
+                .spyOn(duckdb_common_1.DuckDBCommon.prototype, 'runRawSQL')
+                .mockResolvedValue({ rows: [], totalRows: 0 });
+        });
+        afterEach(() => {
+            jest.resetAllMocks();
+            runRawSQL.mockRestore();
+        });
+        it('caches table schema', async () => {
+            await connection.fetchSchemaForTables({ 'test1': 'table1' }, {});
+            expect(runRawSQL).toBeCalledTimes(1);
+            await new Promise(resolve => setTimeout(resolve));
+            await connection.fetchSchemaForTables({ 'test1': 'table1' }, {});
+            expect(runRawSQL).toBeCalledTimes(1);
+        });
+        it('refreshes table schema', async () => {
+            await connection.fetchSchemaForTables({ 'test2': 'table2' }, {});
+            expect(runRawSQL).toBeCalledTimes(1);
+            await new Promise(resolve => setTimeout(resolve));
+            await connection.fetchSchemaForTables({ 'test2': 'table2' }, { refreshTimestamp: Date.now() + 10 });
+            expect(runRawSQL).toBeCalledTimes(2);
+        });
+        it('caches sql schema', async () => {
+            await connection.fetchSchemaForSQLBlock(SQL_BLOCK_1, {});
+            expect(runRawSQL).toBeCalledTimes(1);
+            await new Promise(resolve => setTimeout(resolve));
+            await connection.fetchSchemaForSQLBlock(SQL_BLOCK_1, {});
+            expect(runRawSQL).toBeCalledTimes(1);
+        });
+        it('refreshes sql schema', async () => {
+            await connection.fetchSchemaForSQLBlock(SQL_BLOCK_2, {});
+            expect(runRawSQL).toBeCalledTimes(1);
+            await new Promise(resolve => setTimeout(resolve));
+            await connection.fetchSchemaForSQLBlock(SQL_BLOCK_2, {
+                refreshTimestamp: Date.now() + 10,
+            });
+            expect(runRawSQL).toBeCalledTimes(2);
+        });
     });
-    it('refreshes sql schema', async () => {
-        await connection.fetchSchemaForSQLBlock(SQL_BLOCK_2, {});
-        expect(runRawSQL).toBeCalledTimes(1);
-        await new Promise(resolve => setTimeout(resolve));
-        await connection.fetchSchemaForSQLBlock(SQL_BLOCK_2, {
-            refreshTimestamp: Date.now() + 10,
+    describe('multiple connections', () => {
+        it('can open multiple connections with different settings', async () => {
+            const connection1 = new duckdb_connection_1.DuckDBConnection('duckdb1');
+            const connection2 = new duckdb_connection_1.DuckDBConnection('duckdb2');
+            await connection1.runRawSQL("SET FILE_SEARCH_PATH='/home/user1'");
+            await connection2.runRawSQL("SET FILE_SEARCH_PATH='/home/user2'");
+            const val1 = await connection1.runSQL("SELECT current_setting('FILE_SEARCH_PATH') AS val");
+            const val2 = await connection2.runSQL("SELECT current_setting('FILE_SEARCH_PATH') AS val");
+            expect(Object.keys(duckdb_connection_1.DuckDBConnection.activeDBs).length).toEqual(1);
+            expect(duckdb_connection_1.DuckDBConnection.activeDBs[':memory:'].connections.length).toEqual(3);
+            expect(val1).toEqual({ rows: [{ val: '/home/user1' }], totalRows: 1 });
+            expect(val2).toEqual({ rows: [{ val: '/home/user2' }], totalRows: 1 });
+            await connection1.close();
+            await connection2.close();
         });
-        expect(runRawSQL).toBeCalledTimes(2);
     });
 });
 const SQL_BLOCK_1 = {

package/dist/duckdb_connection.d.ts

@@ -1,14 +1,18 @@
 import { DuckDBCommon, QueryOptionsReader } from './duckdb_common';
 import { Connection, Database, TableData } from 'duckdb';
 import { QueryDataRow, RunSQLOptions } from '@malloydata/malloy';
+interface ActiveDB {
+    database: Database;
+    connections: Connection[];
+}
 export declare class DuckDBConnection extends DuckDBCommon {
     readonly name: string;
     private databasePath;
     private workingDirectory;
     connecting: Promise<void>;
     protected connection: Connection | null;
-    protected database: Database | null;
     protected isSetup: Promise<void> | undefined;
+    static activeDBs: Record<string, ActiveDB>;
     constructor(name: string, databasePath?: string, workingDirectory?: string, queryOptions?: QueryOptionsReader);
     private init;
     loadExtension(ext: string): Promise<void>;
@@ -21,3 +25,4 @@ export declare class DuckDBConnection extends DuckDBCommon {
     createHash(sqlCommand: string): Promise<string>;
     close(): Promise<void>;
 }
+export {};

package/dist/duckdb_connection.js

@@ -36,19 +36,30 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
         this.databasePath = databasePath;
         this.workingDirectory = workingDirectory;
         this.connection = null;
-        this.database = null;
         this.connecting = this.init();
     }
     async init() {
         return new Promise((resolve, reject) => {
-            this.database = new duckdb_1.Database(this.databasePath, duckdb_1.OPEN_READWRITE, // databasePath === ":memory:" ? OPEN_READWRITE : OPEN_READONLY,
-            // databasePath === ":memory:" ? OPEN_READWRITE : OPEN_READONLY,
-            err => {
-                if (err) {
-                    reject(err);
-                }
-            });
-            this.connection = this.database.connect();
+            let activeDB;
+            if (this.databasePath in DuckDBConnection.activeDBs) {
+                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 => {
+                    if (err) {
+                        reject(err);
+                    }
+                });
+                activeDB = {
+                    database,
+                    connections: [],
+                };
+                DuckDBConnection.activeDBs[this.databasePath] = activeDB;
+            }
+            this.connection = activeDB.database.connect();
+            activeDB.connections.push(this.connection);
             resolve();
         });
     }
@@ -137,14 +148,16 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
         return crypto_1.default.createHash('md5').update(sqlCommand).digest('hex');
     }
     async close() {
-        if (this.connection) {
-            this.connection = null;
-        }
-        if (this.database) {
-            this.database.close();
-            this.database = null;
+        const activeDB = DuckDBConnection.activeDBs[this.databasePath];
+        if (activeDB) {
+            activeDB.connections = activeDB.connections.filter(connection => connection !== this.connection);
+            if (activeDB.connections.length === 0) {
+                activeDB.database.close();
+                delete DuckDBConnection.activeDBs[this.databasePath];
+            }
         }
     }
 }
 exports.DuckDBConnection = DuckDBConnection;
+DuckDBConnection.activeDBs = {};
 //# sourceMappingURL=duckdb_connection.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-duckdb",
-  "version": "0.0.120-dev240125201336",
+  "version": "0.0.120-dev240131220338",
   "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-dev240125201336",
+    "@malloydata/malloy": "^0.0.120-dev240131220338",
     "apache-arrow": "^13.0.0",
     "duckdb": "0.9.2",
     "web-worker": "^1.2.0"