@malloydata/db-postgres 0.0.100-dev231106165927 → 0.0.100-dev231106210358

package/dist/postgres_connection.d.ts

@@ -1,5 +1,5 @@
-import { Connection, MalloyQueryData, PersistSQLResults, PooledConnection, QueryData, QueryDataRow, QueryRunStats, RunSQLOptions, SQLBlock, StreamingConnection, StructDef } from '@malloydata/malloy';
-import { Client } from 'pg';
+import { Connection, MalloyQueryData, PersistSQLResults, PooledConnection, QueryDataRow, QueryRunStats, RunSQLOptions, SQLBlock, StreamingConnection, StructDef } from '@malloydata/malloy';
+import { Client, Pool, QueryResult } from 'pg';
 import { FetchSchemaOptions } from '@malloydata/malloy-interfaces';
 interface PostgresQueryConfiguration {
     rowLimit?: number;
@@ -23,7 +23,7 @@ export declare class PostgresConnection implements Connection, StreamingConnecti
     private sqlSchemaCache;
     constructor(name: string, queryConfigReader?: PostgresQueryConfigurationReader, configReader?: PostgresConnectionConfigurationReader);
     private readQueryConfig;
-    private readConfig;
+    protected readConfig(): Promise<PostgresConnectionConfiguration>;
     get dialectName(): string;
     isPool(): this is PooledConnection;
     canPersist(): this is PersistSQLResults;
@@ -45,9 +45,9 @@ export declare class PostgresConnection implements Connection, StreamingConnecti
     private getSQLBlockSchema;
     private schemaFromQuery;
     private getTableSchema;
-    executeSQLRaw(query: string): Promise<QueryData>;
+    executeSQLRaw(query: string): Promise<QueryResult>;
     test(): Promise<void>;
-    connectionSetup(): Promise<void>;
+    connectionSetup(client: Client): Promise<void>;
     runSQL(sql: string, { rowLimit }?: RunSQLOptions, rowIndex?: number): Promise<MalloyQueryData>;
     runSQLStream(sqlCommand: string, options?: {
         rowLimit?: number;
@@ -57,12 +57,12 @@ export declare class PostgresConnection implements Connection, StreamingConnecti
     close(): Promise<void>;
 }
 export declare class PooledPostgresConnection extends PostgresConnection implements PooledConnection {
-    private pool;
+    private _pool;
     constructor(name: string, queryConfigReader?: PostgresQueryConfigurationReader, configReader?: PostgresConnectionConfigurationReader);
     isPool(): true;
     drain(): Promise<void>;
+    getPool(): Promise<Pool>;
     protected runPostgresQuery(sqlCommand: string, _pageSize: number, _rowIndex: number, deJSON: boolean): Promise<MalloyQueryData>;
-    private getClientFromPool;
     runSQLStream(sqlCommand: string, options?: {
         rowLimit?: number;
     }): AsyncIterableIterator<QueryDataRow>;

package/dist/postgres_connection.js

@@ -163,7 +163,7 @@ class PostgresConnection {
     async runPostgresQuery(sqlCommand, _pageSize, _rowIndex, deJSON) {
         const client = await this.getClient();
         await client.connect();
-        await this.connectionSetup();
+        await this.connectionSetup(client);
         let result = await client.query(sqlCommand);
         if (Array.isArray(result)) {
             result = result.pop();
@@ -274,18 +274,17 @@ class PostgresConnection {
         return structDef;
     }
     async executeSQLRaw(query) {
-        const config = await this.readQueryConfig();
-        const queryData = await this.runPostgresQuery(query, config.rowLimit || DEFAULT_PAGE_SIZE, 0, false);
-        return queryData.rows;
+        const client = await this.getClient();
+        await client.connect();
+        const results = await client.query(query);
+        await client.end();
+        return results;
     }
     async test() {
         await this.executeSQLRaw('SELECT 1');
     }
-    async connectionSetup() {
-        if (!this.isSetup) {
-            this.executeSQLRaw("SET TIME ZONE 'UTC'");
-            this.isSetup = true;
-        }
+    async connectionSetup(client) {
+        await client.query("SET TIME ZONE 'UTC'");
     }
     async runSQL(sql, { rowLimit } = {}, rowIndex = 0) {
         var _a;
@@ -328,17 +327,31 @@ exports.PostgresConnection = PostgresConnection;
 class PooledPostgresConnection extends PostgresConnection {
     constructor(name, queryConfigReader = {}, configReader = {}) {
         super(name, queryConfigReader, configReader);
-        this.pool = new pg_1.Pool();
-        this.pool.on('acquire', client => client.query("SET TIME ZONE 'UTC'"));
     }
     isPool() {
         return true;
     }
     async drain() {
-        await this.pool.end();
+        var _a;
+        await ((_a = this._pool) === null || _a === void 0 ? void 0 : _a.end());
+    }
+    async getPool() {
+        if (!this._pool) {
+            const { username: user, password, databaseName: database, port, host, } = await this.readConfig();
+            this._pool = new pg_1.Pool({
+                user,
+                password,
+                database,
+                port,
+                host,
+            });
+            this._pool.on('acquire', client => client.query("SET TIME ZONE 'UTC'"));
+        }
+        return this._pool;
     }
     async runPostgresQuery(sqlCommand, _pageSize, _rowIndex, deJSON) {
-        let result = await this.pool.query(sqlCommand);
+        const pool = await this.getPool();
+        let result = await pool.query(sqlCommand);
         if (Array.isArray(result)) {
             result = result.pop();
         }
@@ -352,16 +365,6 @@ class PooledPostgresConnection extends PostgresConnection {
             totalRows: result.rows.length,
         };
     }
-    async getClientFromPool() {
-        return await new Promise((resolve, reject) => this.pool.connect((error, client, releaseClient) => {
-            if (error) {
-                reject(error);
-            }
-            else {
-                resolve([client, releaseClient]);
-            }
-        }));
-    }
     async *runSQLStream(sqlCommand, options) {
         const query = new pg_query_stream_1.default(sqlCommand);
         let index = 0;
@@ -369,7 +372,8 @@ class PooledPostgresConnection extends PostgresConnection {
         // type. Because `query` is a `QueryStream`, the result is supposed to be a
         // `QueryStream` as well, but it's not. So instead, we get a client and call
         // `client.query(query)`, which does what it's supposed to.
-        const [client, releaseClient] = await this.getClientFromPool();
+        const pool = await this.getPool();
+        const client = await pool.connect();
         const resultStream = client.query(query);
         for await (const row of resultStream) {
             yield row.row;
@@ -379,7 +383,7 @@ class PooledPostgresConnection extends PostgresConnection {
                 break;
             }
         }
-        releaseClient();
+        client.release();
     }
     async close() {
         await this.drain();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-postgres",
-  "version": "0.0.100-dev231106165927",
+  "version": "0.0.100-dev231106210358",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,8 +22,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@malloydata/malloy": "^0.0.100-dev231106165927",
-    "@malloydata/malloy-interfaces": "^0.0.100-dev231106165927",
+    "@malloydata/malloy": "^0.0.100-dev231106210358",
+    "@malloydata/malloy-interfaces": "^0.0.100-dev231106210358",
     "@types/pg": "^8.6.1",
     "pg": "^8.7.1",
     "pg-query-stream": "4.2.3"