@malloydata/db-postgres 0.0.24-dev230224184907 → 0.0.24-dev230228224434

package/dist/index.d.ts

@@ -1 +1 @@
-export { PostgresConnection, PooledPostgresConnection } from "./postgres_connection";
+export { PostgresConnection, PooledPostgresConnection, } from './postgres_connection';

package/dist/postgres_connection.d.ts

@@ -1,5 +1,5 @@
-import { Connection, MalloyQueryData, PersistSQLResults, PooledConnection, QueryData, QueryDataRow, RunSQLOptions, SQLBlock, StreamingConnection, StructDef } from "@malloydata/malloy";
-import { Client } from "pg";
+import { Connection, MalloyQueryData, PersistSQLResults, PooledConnection, QueryData, QueryDataRow, RunSQLOptions, SQLBlock, StreamingConnection, StructDef } from '@malloydata/malloy';
+import { Client } from 'pg';
 interface PostgresQueryConfiguration {
     rowLimit?: number;
 }

package/dist/postgres_connection.js

@@ -60,31 +60,31 @@ const pg_1 = require("pg");
 const pg_query_stream_1 = __importDefault(require("pg-query-stream"));
 const crypto_1 = require("crypto");
 const postgresToMalloyTypes = {
-    "character varying": "string",
-    "name": "string",
-    "text": "string",
-    "date": "date",
-    "integer": "number",
-    "bigint": "number",
-    "double precision": "number",
-    "timestamp without time zone": "timestamp",
-    "oid": "string",
-    "boolean": "boolean",
+    'character varying': 'string',
+    name: 'string',
+    text: 'string',
+    date: 'date',
+    integer: 'number',
+    bigint: 'number',
+    'double precision': 'number',
+    'timestamp without time zone': 'timestamp',
+    oid: 'string',
+    boolean: 'boolean',
     // ARRAY: "string",
-    "timestamp with time zone": "timestamp",
-    "timestamp": "timestamp",
-    '"char"': "string",
-    "character": "string",
-    "smallint": "number",
-    "xid": "string",
-    "real": "number",
-    "interval": "string",
-    "inet": "string",
-    "regtype": "string",
-    "numeric": "number",
-    "bytea": "string",
-    "pg_ndistinct": "number",
-    "uuid": "string"
+    'timestamp with time zone': 'timestamp',
+    timestamp: 'timestamp',
+    '"char"': 'string',
+    character: 'string',
+    smallint: 'number',
+    xid: 'string',
+    real: 'number',
+    interval: 'string',
+    inet: 'string',
+    regtype: 'string',
+    numeric: 'number',
+    bytea: 'string',
+    pg_ndistinct: 'number',
+    uuid: 'string',
 };
 const DEFAULT_PAGE_SIZE = 1000;
 const SCHEMA_PAGE_SIZE = 1000;
@@ -113,7 +113,7 @@ class PostgresConnection {
         }
     }
     get dialectName() {
-        return "postgres";
+        return 'postgres';
     }
     isPool() {
         return false;
@@ -132,12 +132,12 @@ class PostgresConnection {
             if (!inCache) {
                 try {
                     inCache = {
-                        "schema": await this.getTableSchema(tableURL)
+                        schema: await this.getTableSchema(tableURL),
                     };
                     this.schemaCache.set(tableURL, inCache);
                 }
                 catch (error) {
-                    inCache = { "error": error.message };
+                    inCache = { error: error.message };
                 }
             }
             if (inCache.schema !== undefined) {
@@ -155,11 +155,11 @@ class PostgresConnection {
         if (!inCache) {
             try {
                 inCache = {
-                    "structDef": await this.getSQLBlockSchema(sqlRef)
+                    structDef: await this.getSQLBlockSchema(sqlRef),
                 };
             }
             catch (error) {
-                inCache = { "error": error.message };
+                inCache = { error: error.message };
             }
             this.sqlSchemaCache.set(key, inCache);
         }
@@ -168,11 +168,11 @@ class PostgresConnection {
     async getClient() {
         const config = await this.readConfig();
         return new pg_1.Client({
-            "user": config.username,
-            "password": config.password,
-            "database": config.databaseName,
-            "port": config.port,
-            "host": config.host
+            user: config.username,
+            password: config.password,
+            database: config.databaseName,
+            port: config.port,
+            host: config.host,
         });
     }
     async runPostgresQuery(sqlCommand, _pageSize, _rowIndex, deJSON) {
@@ -189,27 +189,27 @@ class PostgresConnection {
         }
         await client.end();
         return {
-            "rows": result.rows,
-            "totalRows": result.rows.length
+            rows: result.rows,
+            totalRows: result.rows.length,
         };
     }
     async getSQLBlockSchema(sqlRef) {
         const structDef = {
-            "type": "struct",
-            "dialect": "postgres",
-            "name": sqlRef.name,
-            "structSource": {
-                "type": "sql",
-                "method": "subquery",
-                "sqlBlock": sqlRef
+            type: 'struct',
+            dialect: 'postgres',
+            name: sqlRef.name,
+            structSource: {
+                type: 'sql',
+                method: 'subquery',
+                sqlBlock: sqlRef,
             },
-            "structRelationship": {
-                "type": "basetable",
-                "connectionName": this.name
+            structRelationship: {
+                type: 'basetable',
+                connectionName: this.name,
             },
-            "fields": []
+            fields: [],
         };
-        const tempTableName = `tmp${(0, crypto_1.randomUUID)()}`.replace(/-/g, "");
+        const tempTableName = `tmp${(0, crypto_1.randomUUID)()}`.replace(/-/g, '');
         const infoQuery = `
       drop table if exists ${tempTableName};
       create temp table ${tempTableName} as SELECT * FROM (
@@ -227,35 +227,35 @@ class PostgresConnection {
     async schemaFromQuery(infoQuery, structDef) {
         const result = await this.runPostgresQuery(infoQuery, SCHEMA_PAGE_SIZE, 0, false);
         for (const row of result.rows) {
-            const postgresDataType = row["data_type"];
+            const postgresDataType = row['data_type'];
             let s = structDef;
             let malloyType = postgresToMalloyTypes[postgresDataType];
-            let name = row["column_name"];
-            if (postgresDataType === "ARRAY") {
-                malloyType = postgresToMalloyTypes[row["element_type"]];
+            let name = row['column_name'];
+            if (postgresDataType === 'ARRAY') {
+                malloyType = postgresToMalloyTypes[row['element_type']];
                 s = {
-                    "type": "struct",
-                    "name": row["column_name"],
-                    "dialect": this.dialectName,
-                    "structRelationship": {
-                        "type": "nested",
-                        "field": name,
-                        "isArray": true
+                    type: 'struct',
+                    name: row['column_name'],
+                    dialect: this.dialectName,
+                    structRelationship: {
+                        type: 'nested',
+                        field: name,
+                        isArray: true,
                     },
-                    "structSource": { "type": "nested" },
-                    "fields": []
+                    structSource: { type: 'nested' },
+                    fields: [],
                 };
                 structDef.fields.push(s);
-                name = "value";
+                name = 'value';
             }
             if (malloyType) {
-                s.fields.push({ "type": malloyType, name });
+                s.fields.push({ type: malloyType, name });
             }
             else {
                 s.fields.push({
-                    "type": "unsupported",
-                    "rawType": postgresDataType.toLowerCase(),
-                    name
+                    type: 'unsupported',
+                    rawType: postgresDataType.toLowerCase(),
+                    name,
                 });
             }
         }
@@ -263,19 +263,19 @@ class PostgresConnection {
     async getTableSchema(tableURL) {
         const { tablePath } = (0, malloy_1.parseTableURI)(tableURL);
         const structDef = {
-            "type": "struct",
-            "name": tableURL,
-            "dialect": "postgres",
-            "structSource": { "type": "table", tablePath },
-            "structRelationship": {
-                "type": "basetable",
-                "connectionName": this.name
+            type: 'struct',
+            name: tableURL,
+            dialect: 'postgres',
+            structSource: { type: 'table', tablePath },
+            structRelationship: {
+                type: 'basetable',
+                connectionName: this.name,
             },
-            "fields": []
+            fields: [],
         };
-        const [schema, table] = tablePath.split(".");
+        const [schema, table] = tablePath.split('.');
         if (table === undefined) {
-            throw new Error("Default schema not yet supported in Postgres");
+            throw new Error('Default schema not yet supported in Postgres');
         }
         const infoQuery = `
       SELECT column_name, c.data_type, e.data_type as element_type
@@ -294,7 +294,7 @@ class PostgresConnection {
         return queryData.rows;
     }
     async test() {
-        await this.executeSQLRaw("SELECT 1");
+        await this.executeSQLRaw('SELECT 1');
     }
     async runSQL(sql, { rowLimit } = {}, rowIndex = 0) {
         var _a;
@@ -318,7 +318,7 @@ class PostgresConnection {
         await client.end();
     }
     async manifestTemporaryTable(sqlCommand) {
-        const hash = crypto.createHash("md5").update(sqlCommand).digest("hex");
+        const hash = crypto.createHash('md5').update(sqlCommand).digest('hex');
         const tableName = `tt${hash}`;
         const cmd = `CREATE TEMPORARY TABLE IF NOT EXISTS ${tableName} AS (${sqlCommand});`;
         // console.log(cmd);
@@ -352,8 +352,8 @@ class PooledPostgresConnection extends PostgresConnection {
             }
         }
         return {
-            "rows": result.rows,
-            "totalRows": result.rows.length
+            rows: result.rows,
+            totalRows: result.rows.length,
         };
     }
     async getClientFromPool() {

package/package.json

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