@malloydata/db-postgres 0.0.295 → 0.0.296

package/dist/postgres_connection.js

@@ -69,7 +69,6 @@ const malloy_1 = require("@malloydata/malloy");
 const connection_1 = require("@malloydata/malloy/connection");
 const pg_1 = require("pg");
 const pg_query_stream_1 = __importDefault(require("pg-query-stream"));
-const crypto_1 = require("crypto");
 const DEFAULT_PAGE_SIZE = 1000;
 const SCHEMA_PAGE_SIZE = 1000;
 class PostgresConnection extends connection_1.BaseConnection {
@@ -162,24 +161,94 @@ class PostgresConnection extends connection_1.BaseConnection {
             fields: [],
             name: (0, malloy_1.sqlKey)(sqlRef.connection, sqlRef.selectStr),
         };
-        const tempTableName = `tmp${(0, crypto_1.randomUUID)()}`.replace(/-/g, '');
-        const infoQuery = `
-      drop table if exists ${tempTableName};
-      create temp table ${tempTableName} as SELECT * FROM (
-        ${sqlRef.selectStr}
-      ) as x where false;
-      SELECT column_name, c.data_type, e.data_type as element_type
-      FROM information_schema.columns c LEFT JOIN information_schema.element_types e
-        ON ((c.table_catalog, c.table_schema, c.table_name, 'TABLE', c.dtd_identifier)
-          = (e.object_catalog, e.object_schema, e.object_name, e.object_type, e.collection_type_identifier))
-      where table_name='${tempTableName}';
-    `;
-        try {
-            await this.schemaFromQuery(infoQuery, structDef);
+        const client = await this.getClient();
+        await client.connect();
+        await this.connectionSetup(client);
+        // 1) Get row-descriptor without fetching data
+        const res = await client.query({
+            text: `SELECT * FROM (${sqlRef.selectStr}) _t LIMIT 0`,
+        });
+        // 2) Resolve every OID we might touch (field, array element, domain base)
+        const neededOids = new Set();
+        res.fields.forEach(f => neededOids.add(f.dataTypeID));
+        // we'll add more OIDs later (typelem / typebasetype) lazily
+        // helper to fetch pg_type rows on demand, with cache
+        const pgTypeCache = new Map();
+        const loadTypes = async (oids) => {
+            if (oids.length === 0)
+                return;
+            const params = oids.map((_, i) => `$${i + 1}`).join(',');
+            const { rows } = await client.query(`
+      SELECT
+        oid,
+        typname,
+        typtype,
+        typcategory,
+        typelem,
+        typbasetype,
+        format_type(oid, NULL) AS formatted
+      FROM pg_type
+      WHERE oid IN (${params})
+      `, oids);
+            rows.forEach(r => pgTypeCache.set(r.oid, r));
+        };
+        // Prime the cache
+        await loadTypes([...neededOids]);
+        // 3) recursive mapper → info-schema compliant strings
+        const mapDataType = async (oid) => {
+            let t = pgTypeCache.get(oid);
+            if (!t) {
+                await loadTypes([oid]);
+                t = pgTypeCache.get(oid);
+            }
+            // ARRAY?
+            if (t.typcategory === 'A')
+                return 'ARRAY';
+            // DOMAIN?  recurse to its base type
+            if (t.typtype === 'd')
+                return mapDataType(t.typbasetype);
+            // ENUM, COMPOSITE, RANGE, MULTIRANGE, PSEUDO  → USER-DEFINED
+            if (['e', 'c', 'r', 'm', 'p'].includes(t.typtype))
+                return 'USER-DEFINED';
+            // built-in scalar or base type of domain
+            return t.formatted;
+        };
+        // helper to resolve element_type (NULL for scalars)
+        const mapElementType = async (oid) => {
+            let t = pgTypeCache.get(oid);
+            if (!t) {
+                await loadTypes([oid]);
+                t = pgTypeCache.get(oid);
+            }
+            if (t.typcategory !== 'A')
+                return null; // not an array
+            // Ensure element row cached
+            if (!pgTypeCache.has(t.typelem))
+                await loadTypes([t.typelem]);
+            return mapDataType(t.typelem);
+        };
+        // 4) Build final array in original column order
+        const result = [];
+        for (const field of res.fields) {
+            result.push({
+                columnName: field.name,
+                dataType: await mapDataType(field.dataTypeID),
+                elementType: await mapElementType(field.dataTypeID),
+            });
         }
-        catch (error) {
-            return `Error fetching schema for ${structDef.name}: ${error}`;
+        for (const row of result) {
+            const postgresDataType = row.dataType;
+            const name = row.columnName;
+            if (postgresDataType === 'ARRAY') {
+                const elementType = this.dialect.sqlTypeToMalloyType(row.elementType);
+                structDef.fields.push((0, malloy_1.mkArrayDef)(elementType, name));
+            }
+            else {
+                const malloyType = this.dialect.sqlTypeToMalloyType(postgresDataType);
+                structDef.fields.push({ ...malloyType, name });
+            }
         }
+        await client.end();
         return structDef;
     }
     async schemaFromQuery(infoQuery, structDef) {

package/package.json

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