@malloydata/db-trino 0.0.135-dev240326020414 → 0.0.135-dev240326154530

package/dist/trino_connection.d.ts

@@ -48,13 +48,16 @@ export declare class TrinoConnection implements Connection, PersistSQLResults {
         errors: Record<string, string>;
     }>;
     private structDefFromTableSchema;
-    fetchSchemaForSQLBlock(_sqlRef: SQLBlock, { refreshTimestamp }: FetchSchemaOptions): Promise<{
+    fetchSchemaForSQLBlock(sqlRef: SQLBlock, { refreshTimestamp }: FetchSchemaOptions): Promise<{
         structDef: StructDef;
         error?: undefined;
     } | {
         error: string;
         structDef?: undefined;
     }>;
+    private structDefFromSqlBlock;
+    private executeAndWait;
+    private loadSchemaForSqlBlock;
     estimateQueryCost(_sqlCommand: string): Promise<QueryRunStats>;
     executeSQLRaw(_sqlCommand: string): Promise<QueryData>;
     test(): Promise<void>;

package/dist/trino_connection.js

@@ -24,6 +24,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrinoConnection = void 0;
 const malloy_1 = require("@malloydata/malloy");
+const crypto_1 = require("crypto");
 const trino_client_1 = require("trino-client");
 // manage access to BQ, control costs, enforce global data/API limits
 class TrinoConnection {
@@ -254,7 +255,6 @@ class TrinoConnection {
         return { schemas: schemas, errors: errors };
     }
     async structDefFromTableSchema(tableKey, tablePath) {
-        var _a, _b;
         const structDef = {
             type: 'struct',
             name: tableKey,
@@ -269,12 +269,63 @@ class TrinoConnection {
             },
             fields: [],
         };
+        return await this.loadSchemaForSqlBlock(`DESCRIBE ${tablePath}`, structDef, `table ${tablePath}`);
+    }
+    async fetchSchemaForSQLBlock(sqlRef, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    { refreshTimestamp }) {
+        const key = sqlRef.name;
+        let inCache = this.sqlSchemaCache.get(key);
+        if (!inCache ||
+            (refreshTimestamp && refreshTimestamp > inCache.timestamp)) {
+            const timestamp = refreshTimestamp !== null && refreshTimestamp !== void 0 ? refreshTimestamp : Date.now();
+            try {
+                inCache = {
+                    structDef: await this.structDefFromSqlBlock(sqlRef),
+                    timestamp,
+                };
+            }
+            catch (error) {
+                inCache = { error: error.message, timestamp };
+            }
+            this.sqlSchemaCache.set(key, inCache);
+        }
+        return inCache;
+    }
+    async structDefFromSqlBlock(sqlRef) {
+        const structDef = {
+            type: 'struct',
+            name: sqlRef.name,
+            dialect: this.dialectName,
+            structSource: {
+                type: 'sql',
+                method: 'subquery',
+                sqlBlock: sqlRef,
+            },
+            structRelationship: {
+                type: 'basetable',
+                connectionName: this.name,
+            },
+            fields: [],
+        };
+        const tmpQueryName = `myMalloyQuery${(0, crypto_1.randomUUID)().replace(/-/g, '')}`;
+        await this.executeAndWait(`PREPARE ${tmpQueryName} FROM ${sqlRef.selectStr}`);
+        return await this.loadSchemaForSqlBlock(`DESCRIBE OUTPUT ${tmpQueryName}`, structDef, `query ${sqlRef.selectStr.substring(0, 50)}`);
+    }
+    async executeAndWait(sqlBlock) {
+        const result = await this.trino.query(sqlBlock);
+        // TODO: make sure failure is handled correctly.
+        while (!(await result.next()).done)
+            ;
+    }
+    async loadSchemaForSqlBlock(sqlBlock, structDef, element) {
+        var _a, _b;
         try {
-            const result = await this.trino.query(`DESCRIBE ${tablePath}`);
+            const result = await this.trino.query(sqlBlock);
             const queryResult = await result.next();
             if (queryResult.value.error) {
                 // TODO: handle.
-                throw new Error(`Failed to grab schema for table ${tablePath}: ${JSON.stringify(queryResult.value.error)}`);
+                throw new Error(`Failed to grab schema for ${element}: ${JSON.stringify(queryResult.value.error)}`);
             }
             const rows = (_a = queryResult.value.data) !== null && _a !== void 0 ? _a : [];
             for (const row of rows) {
@@ -288,16 +339,10 @@ class TrinoConnection {
             }
         }
         catch (e) {
-            throw new Error(`Could not fetch schema for table ${tablePath} ${e}`);
+            throw new Error(`Could not fetch schema for ${element} ${e}`);
         }
-        // TODO: handle repeated etc.
         return structDef;
     }
-    async fetchSchemaForSQLBlock(_sqlRef, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    { refreshTimestamp }) {
-        throw new Error('Not implemented 5');
-    }
     /*  public async downloadMalloyQuery(
       sqlCommand: string
     ): Promise<ResourceStream<RowMetadata>> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-trino",
-  "version": "0.0.135-dev240326020414",
+  "version": "0.0.135-dev240326154530",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",