@malloydata/db-trino 0.0.149-dev240704171255 → 0.0.149

package/dist/test.nonspec.d.ts

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

package/dist/test.nonspec.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*import {Trino, BasicAuth} from 'trino-client';
+import PrestoClient from '@prestodb/presto-js-client';
+
+// function CallPresto(client: Client, query: string ) {
+//   return new Promise (resolve => {
+//     client.execute({query, data => resolve(response)})
+//   });
+// }
+
+describe('Trino connection', () => {
+  console.log('hello');
+
+  test('says hello1', async () => {
+    const trino: Trino = Trino.create({
+      server: 'http://localhost:8090',
+      catalog: 'bigquery',
+      schema: 'malloytest',
+      auth: new BasicAuth('test'),
+    });
+    const limit = 50;
+    const result = await trino.query(
+      // 'explain SELECT 1 as one'
+      'explain SELECT * FROM malloytest.ga_sample limit 2'
+    );
+    let queryResult = await result.next();
+    const columns = queryResult.value.columns;
+
+    const outputRows: unknown[] = [];
+    while (queryResult !== null && outputRows.length < limit) {
+      const rows = queryResult.value.data ?? [];
+      for (const row of rows) {
+        if (outputRows.length < limit) {
+          outputRows.push(row);
+        }
+      }
+      if (!queryResult.done) {
+        queryResult = await result.next();
+      } else {
+        break;
+      }
+    }
+
+    const d = outputRows![0]![0];
+    console.log(d);
+
+    // console.log(outputRows);
+    // console.log(columns);
+  });
+
+  test('says hello presto', async () => {
+    const client = new PrestoClient({
+      catalog: 'bigquery',
+      host: 'http://localhost',
+      port: 8080,
+      schema: 'malloytest',
+      timezone: 'America/Costa_Rica',
+      user: 'root',
+    });
+
+    try {
+      const ret = await client.query(
+        'explain SELECT totals  FROM malloytest.ga_sample limit 2'
+        // 'explain select 1 as one, 2 as two'
+      );
+      const d = ret.data![0][0];
+
+
+      // console.log(ret);
+      console.log(d);
+    } catch (error) {
+      console.log(error);
+    }
+  });
+});
+*/ 
+//# sourceMappingURL=test.nonspec.js.map

package/dist/trino_connection.d.ts

@@ -10,27 +10,37 @@ export interface TrinoManagerOptions {
 }
 export interface TrinoConnectionConfiguration {
     server?: string;
+    port?: number;
     catalog?: string;
     schema?: string;
     user?: string;
     password?: string;
 }
-type TrinoConnectionOptions = ConnectionConfig;
-export declare class TrinoConnection implements Connection, PersistSQLResults {
+export type TrinoConnectionOptions = ConnectionConfig;
+export interface BaseConnection {
+    runSQL(sql: string, limit: number | undefined): Promise<{
+        rows: unknown[][];
+        columns: {
+            name: string;
+            type: string;
+            error?: string;
+        }[];
+        error?: string;
+    }>;
+}
+export declare abstract class TrinoPrestoConnection implements Connection, PersistSQLResults {
     trinoToMalloyTypes: {
         [key: string]: FieldAtomicTypeDef;
     };
     private sqlToMalloyType;
-    readonly name: string;
+    name: string;
     private readonly dialect;
     static DEFAULT_QUERY_OPTIONS: RunSQLOptions;
     private schemaCache;
     private sqlSchemaCache;
     private queryOptions?;
-    private config;
-    private trino;
-    constructor(option: TrinoConnectionOptions, queryOptions?: QueryOptionsReader);
-    constructor(name: string, queryOptions?: QueryOptionsReader, config?: TrinoConnectionConfiguration);
+    private client;
+    constructor(name: string, queryOptions?: QueryOptionsReader, pConfig?: TrinoConnectionConfiguration);
     get dialectName(): string;
     private readQueryOptions;
     isPool(): this is PooledConnection;
@@ -38,8 +48,9 @@ export declare class TrinoConnection implements Connection, PersistSQLResults {
     canStream(): this is StreamingConnection;
     get supportsNesting(): boolean;
     manifestTemporaryTable(_sqlCommand: string): Promise<string>;
+    unpackArray(data: unknown): unknown[];
     convertRow(structDef: StructDef, _row: unknown): {};
-    convertNest(structDef: StructDef, data: unknown): {};
+    convertNest(structDef: StructDef, _data: unknown): {};
     runSQL(sqlCommand: string, options?: RunSQLOptions, _rowIndex?: number): Promise<MalloyQueryData>;
     runSQLBlockAndFetchResultSchema(_sqlBlock: SQLBlock, _options?: RunSQLOptions): Promise<{
         data: MalloyQueryData;
@@ -58,14 +69,26 @@ export declare class TrinoConnection implements Connection, PersistSQLResults {
         structDef?: undefined;
     }>;
     private structDefFromSqlBlock;
-    private executeAndWait;
+    protected abstract fillStructDefForSqlBlockSchema(sql: string, structDef: StructDef): Promise<void>;
+    protected executeAndWait(sqlBlock: string): Promise<void>;
     splitColumns(s: string): string[];
     malloyTypeFromTrinoType(name: string, trinoType: string): FieldAtomicTypeDef | StructDef;
     structDefFromSchema(rows: string[][], structDef: StructDef): void;
-    private loadSchemaForSqlBlock;
+    protected loadSchemaForSqlBlock(sqlBlock: string, structDef: StructDef, element: string): Promise<StructDef>;
     estimateQueryCost(_sqlCommand: string): Promise<QueryRunStats>;
     executeSQLRaw(_sqlCommand: string): Promise<QueryData>;
     test(): Promise<void>;
     close(): Promise<void>;
 }
-export {};
+export declare class PrestoConnection extends TrinoPrestoConnection {
+    constructor(name: string, queryOptions?: QueryOptionsReader, config?: TrinoConnectionConfiguration);
+    constructor(option: TrinoConnectionOptions, queryOptions?: QueryOptionsReader);
+    protected fillStructDefForSqlBlockSchema(sql: string, structDef: StructDef): Promise<void>;
+    private schemaFromExplain;
+    unpackArray(data: unknown): unknown[];
+}
+export declare class TrinoConnection extends TrinoPrestoConnection {
+    constructor(name: string, queryOptions?: QueryOptionsReader, config?: TrinoConnectionConfiguration);
+    constructor(option: TrinoConnectionOptions, queryOptions?: QueryOptionsReader);
+    protected fillStructDefForSqlBlockSchema(sql: string, structDef: StructDef): Promise<void>;
+}

package/dist/trino_connection.js

@@ -22,12 +22,86 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrinoConnection = void 0;
+exports.TrinoConnection = exports.PrestoConnection = exports.TrinoPrestoConnection = void 0;
 const malloy_1 = require("@malloydata/malloy");
+const presto_js_client_1 = require("@prestodb/presto-js-client");
 const crypto_1 = require("crypto");
 const trino_client_1 = require("trino-client");
+class PrestoBase {
+    constructor(config) {
+        this.client = new presto_js_client_1.PrestoClient({
+            catalog: config.catalog,
+            host: config.server,
+            port: config.port,
+            schema: config.schema,
+            timezone: 'America/Costa_Rica',
+            user: config.user || 'anyone',
+        });
+    }
+    async runSQL(sql, limit) {
+        let ret = undefined;
+        const q = limit ? `SELECT * FROM(${sql}) LIMIT ${limit}` : sql;
+        let error = undefined;
+        try {
+            ret = (await this.client.query(q)) || [];
+            // console.log(ret);
+        }
+        catch (errorObj) {
+            // console.log(error);
+            error = errorObj.toString();
+        }
+        return {
+            rows: ret && ret.data ? ret.data : [],
+            columns: ret && ret.columns
+                ? ret.columns
+                : [],
+            error,
+        };
+    }
+}
+class TrinooBase {
+    constructor(config) {
+        this.client = trino_client_1.Trino.create({
+            catalog: config.catalog,
+            server: config.server,
+            schema: config.schema,
+            auth: new trino_client_1.BasicAuth(config.user, config.password || ''),
+        });
+    }
+    async runSQL(sql, limit) {
+        var _a;
+        const result = await this.client.query(sql);
+        let queryResult = await result.next();
+        if (queryResult.value.error) {
+            return {
+                rows: [],
+                columns: [],
+                error: JSON.stringify(queryResult.value.error),
+            };
+        }
+        const columns = queryResult.value.columns;
+        const outputRows = [];
+        while (queryResult !== null && (!limit || outputRows.length < limit)) {
+            const rows = (_a = queryResult.value.data) !== null && _a !== void 0 ? _a : [];
+            for (const row of rows) {
+                if (!limit || outputRows.length < limit) {
+                    outputRows.push(row);
+                }
+            }
+            if (!queryResult.done) {
+                queryResult = await result.next();
+            }
+            else {
+                break;
+            }
+        }
+        // console.log(outputRows);
+        // console.log(columns);
+        return { rows: outputRows, columns };
+    }
+}
 // manage access to BQ, control costs, enforce global data/API limits
-class TrinoConnection {
+class TrinoPrestoConnection {
     sqlToMalloyType(sqlType) {
         var _a, _b;
         const baseSqlType = (_b = (_a = sqlType.match(/^(\w+)/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : sqlType;
@@ -36,7 +110,7 @@ class TrinoConnection {
         }
         return undefined;
     }
-    constructor(arg, queryOptions, config = {}) {
+    constructor(name, queryOptions, pConfig) {
         this.trinoToMalloyTypes = {
             'varchar': { type: 'string' },
             'integer': { type: 'number', numberType: 'integer' },
@@ -66,32 +140,19 @@ class TrinoConnection {
         this.dialect = new malloy_1.StandardSQLDialect();
         this.schemaCache = new Map();
         this.sqlSchemaCache = new Map();
-        this.name = 'trino';
-        /* if (typeof arg === 'string') {
-          this.name = arg;
-        } else {
-          const {name, client_email, private_key, ...args} = arg;
-          this.name = name;
-          config = args;
-          if (client_email || private_key) {
-            config.credentials = {
-              client_email,
-              private_key,
-            };
-          }
-        }*/
-        // TODO: check user is set.
-        this.trino = trino_client_1.Trino.create({
-            server: config.server,
-            catalog: 'malloy_demo', //config.catalog,
-            schema: config.schema,
-            auth: new trino_client_1.BasicAuth(config.user, config.password),
-        });
+        const config = pConfig || {};
+        this.name = name;
+        if (name === 'trino') {
+            this.client = new TrinooBase(config);
+        }
+        else {
+            this.client = new PrestoBase(config);
+        }
         this.queryOptions = queryOptions;
-        this.config = config;
+        //this.config = config;
     }
     get dialectName() {
-        return 'trino';
+        return this.name;
     }
     readQueryOptions() {
         const options = TrinoConnection.DEFAULT_QUERY_OPTIONS;
@@ -122,53 +183,12 @@ class TrinoConnection {
     async manifestTemporaryTable(_sqlCommand) {
         throw new Error('not implemented 1');
     }
-    /*  private async _runSQL(
-      sqlCommand: string,
-      {rowLimit, abortSignal}: RunSQLOptions = {},
-      rowIndex = 0
-    ): Promise<{
-      data: MalloyQueryData;
-      schema: Trino.ITableFieldSchema | undefined;
-    }> {
-      const defaultOptions = this.readQueryOptions();
-      const pageSize = rowLimit ?? defaultOptions.rowLimit;
-  
-      try {
-        const queryResultsOptions: QueryResultsOptions = {
-          maxResults: pageSize,
-          startIndex: rowIndex.toString(),
-        };
-  
-        const jobResult = await this.createTrinoJobAndGetResults(
-          sqlCommand,
-          undefined,
-          queryResultsOptions,
-          abortSignal
-        );
-  
-        const totalRows = +(jobResult[2]?.totalRows
-          ? jobResult[2].totalRows
-          : '0');
-  
-        // TODO even though we have 10 minute timeout limit, we still should confirm that resulting metadata has "jobComplete: true"
-        const queryCostBytes = jobResult[2]?.totalBytesProcessed;
-        const data: MalloyQueryData = {
-          rows: jobResult[0],
-          totalRows,
-          runStats: {
-            queryCostBytes: queryCostBytes ? +queryCostBytes : undefined,
-          },
-        };
-        const schema = jobResult[2]?.schema;
-  
-        return {data, schema};
-      } catch (e) {
-        throw maybeRewriteError(e);
-      }
-    }*/
+    unpackArray(data) {
+        return data;
+    }
     convertRow(structDef, _row) {
         const retRow = {};
-        const row = _row;
+        const row = this.unpackArray(_row);
         for (let i = 0; i < structDef.fields.length; i++) {
             const field = structDef.fields[i];
             if (field.type === 'struct') {
@@ -187,7 +207,8 @@ class TrinoConnection {
         //console.log(retRow);
         return retRow;
     }
-    convertNest(structDef, data) {
+    convertNest(structDef, _data) {
+        const data = this.unpackArray(_data);
         const ret = [];
         //console.log(
         //   `${JSON.stringify(structDef, null, 2)} ${JSON.stringify(data, null, 2)} `
@@ -204,64 +225,61 @@ class TrinoConnection {
     async runSQL(sqlCommand, options = {}, 
     // TODO(figutierrez): Use.
     _rowIndex = 0) {
-        var _a, _b;
-        const result = await this.trino.query(sqlCommand);
-        let queryResult = await result.next();
-        if (queryResult.value.error) {
-            // TODO: handle.
-            const { failureInfo: _, ...error } = queryResult.value.error;
-            throw new Error(`Failed to execute sql: ${sqlCommand}. \n Error: ${JSON.stringify(error)}`);
-        }
-        const malloyColumns = queryResult.value.columns.map(c => this.malloyTypeFromTrinoType(c.name, c.type));
+        // const result = await this.trino.query(sqlCommand);
+        // let queryResult = await result.next();
+        // if (queryResult.value.error) {
+        //   // TODO: handle.
+        //   const {failureInfo: _, ...error} = queryResult.value.error;
+        //   throw new Error(
+        //     `Failed to execute sql: ${sqlCommand}. \n Error: ${JSON.stringify(
+        //       error
+        //     )}`
+        //   );
+        // }
+        const r = await this.client.runSQL(sqlCommand, options.rowLimit);
+        const inputRows = r.rows;
+        const columns = r.columns;
+        const malloyColumns = columns.map(c => this.malloyTypeFromTrinoType(c.name, c.type));
         // Debugging types
         // const _x = queryResult.value.columns.map(c => console.log(c.type));
         // console.log(JSON.stringify(malloyColumns, null, 2));
         // console.log(JSON.stringify(queryResult.value.data, null, 2));
-        let maxRows = (_a = options.rowLimit) !== null && _a !== void 0 ? _a : 50;
         const malloyRows = [];
-        while (queryResult !== null && maxRows--) {
-            const rows = (_b = queryResult.value.data) !== null && _b !== void 0 ? _b : [];
-            for (const row of rows) {
-                const malloyRow = {};
-                for (let i = 0; i < queryResult.value.columns.length; i++) {
-                    const column = queryResult.value.columns[i];
-                    if (malloyColumns[i].type === 'struct') {
-                        const structDef = malloyColumns[i];
-                        if (structDef.structSource.type === 'inline') {
-                            malloyRow[column.name] = this.convertRow(structDef, row[i]);
-                        }
-                        else {
-                            malloyRow[column.name] = this.convertNest(structDef, row[i]);
-                        }
-                        // console.log(
-                        //   column.name,
-                        //   JSON.stringify(malloyColumns[i], null, 2),
-                        //   JSON.stringify(row[i]),
-                        //   JSON.stringify(malloyRow[column.name])
-                        // );
-                    }
-                    else if (malloyColumns[i].type === 'number' &&
-                        typeof row[i] === 'string') {
-                        // decimal numbers come back as strings
-                        malloyRow[column.name] = +row[i];
-                    }
-                    else if (malloyColumns[i].type === 'timestamp' &&
-                        typeof row[i] === 'string') {
-                        // timestamps come back as strings
-                        malloyRow[column.name] = new Date(row[i]);
+        const rows = inputRows !== null && inputRows !== void 0 ? inputRows : [];
+        for (const row of rows) {
+            const malloyRow = {};
+            for (let i = 0; i < columns.length; i++) {
+                const column = columns[i];
+                if (malloyColumns[i].type === 'struct') {
+                    const structDef = malloyColumns[i];
+                    if (structDef.structSource.type === 'inline') {
+                        malloyRow[column.name] = this.convertRow(structDef, row[i]);
                     }
                     else {
-                        malloyRow[column.name] = row[i];
+                        malloyRow[column.name] = this.convertNest(structDef, row[i]);
                     }
+                    // console.log(
+                    //   column.name,
+                    //   JSON.stringify(malloyColumns[i], null, 2),
+                    //   JSON.stringify(row[i]),
+                    //   JSON.stringify(malloyRow[column.name])
+                    // );
+                }
+                else if (malloyColumns[i].type === 'number' &&
+                    typeof row[i] === 'string') {
+                    // decimal numbers come back as strings
+                    malloyRow[column.name] = Number(row[i]);
+                }
+                else if (malloyColumns[i].type === 'timestamp' &&
+                    typeof row[i] === 'string') {
+                    // timestamps come back as strings
+                    malloyRow[column.name] = new Date(row[i]);
+                }
+                else {
+                    malloyRow[column.name] = row[i];
                 }
-                malloyRows.push(malloyRow);
-            }
-            if (!queryResult.done) {
-                queryResult = await result.next();
-            }
-            else {
-                break;
             }
+            malloyRows.push(malloyRow);
         }
         // TODO(figutierrez): Remove.
         // eslint-disable-next-line no-console
@@ -370,15 +388,13 @@ class TrinoConnection {
             },
             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)}`);
+        await this.fillStructDefForSqlBlockSchema(sqlRef.selectStr, structDef);
+        return structDef;
     }
     async executeAndWait(sqlBlock) {
-        const result = await this.trino.query(sqlBlock);
+        await this.client.runSQL(sqlBlock, undefined);
         // TODO: make sure failure is handled correctly.
-        while (!(await result.next()).done)
-            ;
+        //while (!(await result.next()).done);
     }
     splitColumns(s) {
         const columns = [];
@@ -471,7 +487,8 @@ class TrinoConnection {
                     parts = innerType.match(/^(.+)\s(\S+)$/);
                 }
                 if (parts) {
-                    const innerName = parts[1];
+                    // remove quotes from the name
+                    const innerName = parts[1].replace(/^"(.+(?="$))"$/, '$1');
                     const innerTrinoType = parts[2];
                     const innerMalloyType = this.malloyTypeFromTrinoType(innerName, innerTrinoType);
                     malloyType.fields.push({ ...innerMalloyType, name: innerName });
@@ -506,17 +523,17 @@ class TrinoConnection {
     async loadSchemaForSqlBlock(sqlBlock, structDef, element) {
         var _a;
         try {
-            const result = await this.trino.query(sqlBlock);
-            const queryResult = await result.next();
-            if (queryResult.value.error) {
+            const queryResult = await this.client.runSQL(sqlBlock, undefined);
+            if (queryResult.error) {
                 // TODO: handle.
-                throw new Error(`Failed to grab schema for ${element}: ${JSON.stringify(queryResult.value.error)}`);
+                throw new Error(`Failed to grab schema for ${queryResult.error}
+          )}`);
             }
-            const rows = (_a = queryResult.value.data) !== null && _a !== void 0 ? _a : [];
+            const rows = (_a = queryResult.rows) !== null && _a !== void 0 ? _a : [];
             this.structDefFromSchema(rows, structDef);
         }
         catch (e) {
-            throw new Error(`Could not fetch schema for ${element} ${e}`);
+            throw new Error(`Could not fetch schema for ${element} ${JSON.stringify(e)}`);
         }
         return structDef;
     }
@@ -545,8 +562,72 @@ class TrinoConnection {
         return;
     }
 }
-exports.TrinoConnection = TrinoConnection;
-TrinoConnection.DEFAULT_QUERY_OPTIONS = {
+exports.TrinoPrestoConnection = TrinoPrestoConnection;
+TrinoPrestoConnection.DEFAULT_QUERY_OPTIONS = {
     rowLimit: 10,
 };
+class PrestoConnection extends TrinoPrestoConnection {
+    constructor(arg, queryOptions, config = {}) {
+        super('presto', queryOptions, config);
+    }
+    async fillStructDefForSqlBlockSchema(sql, structDef) {
+        const explainResult = await this.runSQL(`EXPLAIN ${sql}`, {});
+        this.schemaFromExplain(explainResult, structDef);
+    }
+    schemaFromExplain(explainResult, structDef) {
+        if (explainResult.rows.length === 0) {
+            throw new Error('Received empty explain result when trying to fetch schema.');
+        }
+        const resultFirstRow = explainResult.rows[0];
+        if (resultFirstRow['Query Plan'] === undefined) {
+            throw new Error("Explain result has rows but column 'Query Plan' is not present.");
+        }
+        const expResult = resultFirstRow['Query Plan'];
+        const lines = expResult.split('\n');
+        if ((lines === null || lines === void 0 ? void 0 : lines.length) === 0) {
+            throw new Error('Received invalid explain result when trying to fetch schema.');
+        }
+        let outputLine = lines[0];
+        const namesIndex = outputLine.indexOf('][');
+        outputLine = outputLine.substring(namesIndex + 2);
+        const lineParts = outputLine.split('] => [');
+        if (lineParts.length !== 2) {
+            throw new Error('There was a problem parsing schema from Explain.');
+        }
+        const fieldNamesPart = lineParts[0];
+        const fieldNames = fieldNamesPart.split(',').map(e => e.trim());
+        let schemaData = lineParts[1];
+        schemaData = schemaData.substring(0, schemaData.length - 1);
+        const rawFieldsTarget = schemaData
+            .split(',')
+            .map(e => e.trim())
+            .map(e => e.split(':'));
+        if (rawFieldsTarget.length !== fieldNames.length) {
+            throw new Error('There was a problem parsing schema from Explain. Field names size do not match target fields with types.');
+        }
+        for (let index = 0; index < fieldNames.length; index++) {
+            const name = fieldNames[index];
+            const type = rawFieldsTarget[index][1];
+            structDef.fields.push({
+                name,
+                ...this.malloyTypeFromTrinoType(name, type),
+            });
+        }
+    }
+    unpackArray(data) {
+        return JSON.parse(data);
+    }
+}
+exports.PrestoConnection = PrestoConnection;
+class TrinoConnection extends TrinoPrestoConnection {
+    constructor(arg, queryOptions, config = {}) {
+        super('trino', queryOptions, config);
+    }
+    async fillStructDefForSqlBlockSchema(sql, structDef) {
+        const tmpQueryName = `myMalloyQuery${(0, crypto_1.randomUUID)().replace(/-/g, '')}`;
+        await this.executeAndWait(`PREPARE ${tmpQueryName} FROM ${sql}`);
+        await this.loadSchemaForSqlBlock(`DESCRIBE OUTPUT ${tmpQueryName}`, structDef, `query ${sql.substring(0, 50)}`);
+    }
+}
+exports.TrinoConnection = TrinoConnection;
 //# sourceMappingURL=trino_connection.js.map

package/dist/trino_connection.spec.js

@@ -34,7 +34,7 @@ const DEEP_SCHEMA = 'array(row(a double, b array(row(c integer, d varchar(60))))
 describe('Trino connection', () => {
     let connection;
     beforeAll(() => {
-        connection = new _1.TrinoConnection('trino', {}, _1.TrinoExecutor.getConnectionOptionsFromEnv());
+        connection = new _1.TrinoConnection('trino', {}, _1.TrinoExecutor.getConnectionOptionsFromEnv('trino'));
     });
     afterAll(() => {
         connection.close();

package/dist/trino_executor.d.ts

@@ -1,4 +1,4 @@
 import { TrinoConnectionConfiguration } from './trino_connection';
 export declare class TrinoExecutor {
-    static getConnectionOptionsFromEnv(): TrinoConnectionConfiguration | undefined;
+    static getConnectionOptionsFromEnv(dialectName: 'trino' | 'presto'): TrinoConnectionConfiguration | undefined;
 }

package/dist/trino_executor.js

@@ -23,27 +23,42 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrinoExecutor = void 0;
+// Differences:
+// Trino uses TRINO_SERVER
+// Presto users PRESTO_HOST/PRESTO_PORT
+// Trino requires TRINO_USER
 class TrinoExecutor {
-    static getConnectionOptionsFromEnv() {
-        const server = process.env['TRINO_SERVER'];
-        if (server) {
-            const user = process.env['TRINO_USER'];
-            if (!user) {
+    static getConnectionOptionsFromEnv(dialectName) {
+        const envPrefix = dialectName.toUpperCase();
+        const user = process.env[`${envPrefix}_USER`];
+        let server;
+        let port = undefined;
+        if (dialectName === 'trino') {
+            server = process.env['TRINO_SERVER'];
+            if (!user && server) {
                 throw Error('Trino server specified but no user was provided. Set TRINO_USER and TRINO_PASSWORD environment variables');
             }
-            const password = process.env['TRINO_PASSWORD'];
-            // TODO(figutierrez): We may not need to support these.
-            const catalog = process.env['TRINO_CATALOG'];
-            const schema = process.env['TRINO_SCHEMA'];
-            return {
-                server,
-                user,
-                password,
-                catalog,
-                schema,
-            };
         }
-        return undefined;
+        else {
+            server = process.env['PRESTO_HOST'];
+            port = Number(process.env['PRESTO_PORT']) || 8080;
+        }
+        if (!server) {
+            return undefined;
+        }
+        const password = process.env[`${envPrefix}_PASSWORD`];
+        // TODO(figutierrez): We may not need to support these.
+        const catalog = process.env[`${envPrefix}_CATALOG`];
+        const schema = process.env[`${envPrefix}_SCHEMA`];
+        const ret = {
+            server,
+            user,
+            port,
+            password,
+            catalog,
+            schema,
+        };
+        return ret;
     }
 }
 exports.TrinoExecutor = TrinoExecutor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-trino",
-  "version": "0.0.149-dev240704171255",
+  "version": "0.0.149",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,6 +23,7 @@
   },
   "dependencies": {
     "@malloydata/malloy": "^0.0.130",
+    "@prestodb/presto-js-client": "^1.0.0",
     "gaxios": "^4.2.0",
     "trino-client": "^0.2.2"
   },