@malloydata/db-postgres 0.0.96-dev231025215721 → 0.0.96

package/dist/postgres.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/postgres.spec.js

@@ -0,0 +1,143 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const postgres_connection_1 = require("./postgres_connection");
+/*
+ * !IMPORTANT
+ *
+ * The connection is reused for each test, so if you do not name your tables
+ * and keys uniquely for each test you will see cross test interactions.
+ */
+describe('PostgresConnection', () => {
+    let connection;
+    let getTableSchema;
+    let getSQLBlockSchema;
+    beforeAll(async () => {
+        connection = new postgres_connection_1.PostgresConnection('duckdb');
+        await connection.runSQL('SELECT 1');
+    });
+    afterAll(async () => {
+        await connection.close();
+    });
+    beforeEach(async () => {
+        getTableSchema = jest
+            .spyOn(postgres_connection_1.PostgresConnection.prototype, 'getTableSchema')
+            .mockResolvedValue({
+            type: 'struct',
+            dialect: 'postgres',
+            name: 'name',
+            structSource: { type: 'table', tablePath: 'test' },
+            structRelationship: {
+                type: 'basetable',
+                connectionName: 'postgres',
+            },
+            fields: [],
+        });
+        getSQLBlockSchema = jest
+            .spyOn(postgres_connection_1.PostgresConnection.prototype, 'getSQLBlockSchema')
+            .mockResolvedValue({
+            type: 'struct',
+            dialect: 'postgres',
+            name: 'name',
+            structSource: {
+                type: 'sql',
+                method: 'subquery',
+                sqlBlock: SQL_BLOCK_1,
+            },
+            structRelationship: {
+                type: 'basetable',
+                connectionName: 'postgres',
+            },
+            fields: [],
+        });
+    });
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+    it('caches table schema', async () => {
+        await connection.fetchSchemaForTables({ 'test1': 'table1' }, {});
+        expect(getTableSchema).toBeCalledTimes(1);
+        await new Promise(resolve => setTimeout(resolve));
+        await connection.fetchSchemaForTables({ 'test1': 'table1' }, {});
+        expect(getTableSchema).toBeCalledTimes(1);
+    });
+    it('refreshes table schema', async () => {
+        await connection.fetchSchemaForTables({ 'test2': 'table2' }, {});
+        expect(getTableSchema).toBeCalledTimes(1);
+        await new Promise(resolve => setTimeout(resolve));
+        await connection.fetchSchemaForTables({ 'test2': 'table2' }, { refreshTimestamp: Date.now() });
+        expect(getTableSchema).toBeCalledTimes(2);
+    });
+    it('caches sql schema', async () => {
+        await connection.fetchSchemaForSQLBlock(SQL_BLOCK_1, {});
+        expect(getSQLBlockSchema).toBeCalledTimes(1);
+        await new Promise(resolve => setTimeout(resolve));
+        await connection.fetchSchemaForSQLBlock(SQL_BLOCK_1, {});
+        expect(getSQLBlockSchema).toBeCalledTimes(1);
+    });
+    it('refreshes sql schema', async () => {
+        await connection.fetchSchemaForSQLBlock(SQL_BLOCK_2, {});
+        expect(getSQLBlockSchema).toBeCalledTimes(1);
+        await new Promise(resolve => setTimeout(resolve));
+        await connection.fetchSchemaForSQLBlock(SQL_BLOCK_2, {
+            refreshTimestamp: Date.now(),
+        });
+        expect(getSQLBlockSchema).toBeCalledTimes(2);
+    });
+});
+const SQL_BLOCK_1 = {
+    type: 'sqlBlock',
+    name: 'block1',
+    selectStr: `
+SELECT
+created_at,
+sale_price,
+inventory_item_id
+FROM 'order_items.parquet'
+SELECT
+id,
+product_department,
+product_category,
+created_at AS inventory_items_created_at
+FROM "inventory_items.parquet"
+`,
+};
+const SQL_BLOCK_2 = {
+    type: 'sqlBlock',
+    name: 'block2',
+    selectStr: `
+SELECT
+created_at,
+sale_price,
+inventory_item_id
+FROM read_parquet('order_items2.parquet', arg='value')
+SELECT
+id,
+product_department,
+product_category,
+created_at AS inventory_items_created_at
+FROM read_parquet("inventory_items2.parquet")
+`,
+};
+//# sourceMappingURL=postgres.spec.js.map

package/dist/postgres_connection.d.ts

@@ -1,5 +1,6 @@
 import { Connection, MalloyQueryData, PersistSQLResults, PooledConnection, QueryData, QueryDataRow, QueryRunStats, RunSQLOptions, SQLBlock, StreamingConnection, StructDef } from '@malloydata/malloy';
 import { Client } from 'pg';
+import { FetchSchemaOptions } from '@malloydata/malloy-interfaces';
 interface PostgresQueryConfiguration {
     rowLimit?: number;
 }
@@ -28,11 +29,11 @@ export declare class PostgresConnection implements Connection, StreamingConnecti
     canPersist(): this is PersistSQLResults;
     canStream(): this is StreamingConnection;
     get supportsNesting(): boolean;
-    fetchSchemaForTables(missing: Record<string, string>): Promise<{
+    fetchSchemaForTables(missing: Record<string, string>, { refreshTimestamp }: FetchSchemaOptions): Promise<{
         schemas: Record<string, StructDef>;
         errors: Record<string, string>;
     }>;
-    fetchSchemaForSQLBlock(sqlRef: SQLBlock): Promise<{
+    fetchSchemaForSQLBlock(sqlRef: SQLBlock, { refreshTimestamp }: FetchSchemaOptions): Promise<{
         structDef: StructDef;
         error?: undefined;
     } | {

package/dist/postgres_connection.js

@@ -102,21 +102,24 @@ class PostgresConnection {
     get supportsNesting() {
         return true;
     }
-    async fetchSchemaForTables(missing) {
+    async fetchSchemaForTables(missing, { refreshTimestamp }) {
         const schemas = {};
         const errors = {};
         for (const tableKey in missing) {
             let inCache = this.schemaCache.get(tableKey);
-            if (!inCache) {
+            if (!inCache ||
+                (refreshTimestamp && refreshTimestamp > inCache.timestamp)) {
                 const tablePath = missing[tableKey];
+                const timestamp = refreshTimestamp || Date.now();
                 try {
                     inCache = {
                         schema: await this.getTableSchema(tableKey, tablePath),
+                        timestamp,
                     };
                     this.schemaCache.set(tableKey, inCache);
                 }
                 catch (error) {
-                    inCache = { error: error.message };
+                    inCache = { error: error.message, timestamp };
                 }
             }
             if (inCache.schema !== undefined) {
@@ -128,17 +131,20 @@ class PostgresConnection {
         }
         return { schemas, errors };
     }
-    async fetchSchemaForSQLBlock(sqlRef) {
+    async fetchSchemaForSQLBlock(sqlRef, { refreshTimestamp }) {
         const key = sqlRef.name;
         let inCache = this.sqlSchemaCache.get(key);
-        if (!inCache) {
+        if (!inCache ||
+            (refreshTimestamp && refreshTimestamp > inCache.timestamp)) {
+            const timestamp = refreshTimestamp !== null && refreshTimestamp !== void 0 ? refreshTimestamp : Date.now();
             try {
                 inCache = {
                     structDef: await this.getSQLBlockSchema(sqlRef),
+                    timestamp,
                 };
             }
             catch (error) {
-                inCache = { error: error.message };
+                inCache = { error: error.message, timestamp };
             }
             this.sqlSchemaCache.set(key, inCache);
         }

package/package.json

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