@malloydata/db-trino 0.0.337 → 0.0.338

package/dist/index.js

@@ -41,6 +41,7 @@ function configToTrinoConfig(config) {
             schema: typeof config['schema'] === 'string' ? config['schema'] : undefined,
             user: typeof config['user'] === 'string' ? config['user'] : undefined,
             password: typeof config['password'] === 'string' ? config['password'] : undefined,
+            setupSQL: typeof config['setupSQL'] === 'string' ? config['setupSQL'] : undefined,
         },
     };
 }
@@ -51,6 +52,13 @@ const trinoProperties = [
     { name: 'schema', displayName: 'Schema', type: 'string', optional: true },
     { name: 'user', displayName: 'User', type: 'string', optional: true },
     { name: 'password', displayName: 'Password', type: 'password', optional: true },
+    {
+        name: 'setupSQL',
+        displayName: 'Setup SQL',
+        type: 'text',
+        optional: true,
+        description: 'SQL statements to run when the connection is established',
+    },
 ];
 (0, malloy_1.registerConnectionType)('trino', {
     factory: (config) => {

package/dist/result-to-querydata.d.ts

@@ -0,0 +1,14 @@
+import type { FieldDef, QueryRecord } from '@malloydata/malloy';
+/**
+ * Converts a raw compound value (record or array) from its wire
+ * format into a JavaScript array.
+ * - Trino: identity cast (data is already an array)
+ * - Presto: JSON.parse (data comes as a JSON string)
+ */
+export type Unpacker = (data: unknown) => unknown[];
+/**
+ * Convert a raw database result row (positional array) into a
+ * QueryRecord (named object). Each position in the raw row
+ * corresponds to a column defined in the schema.
+ */
+export declare function resultRowToQueryRecord(columns: FieldDef[], rawRow: unknown[], unpack: Unpacker): QueryRecord;

package/dist/result-to-querydata.js

@@ -0,0 +1,123 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resultRowToQueryRecord = resultRowToQueryRecord;
+const malloy_1 = require("@malloydata/malloy");
+const luxon_1 = require("luxon");
+/**
+ * Convert a raw database result row (positional array) into a
+ * QueryRecord (named object). Each position in the raw row
+ * corresponds to a column defined in the schema.
+ */
+function resultRowToQueryRecord(columns, rawRow, unpack) {
+    const result = {};
+    for (let i = 0; i < columns.length; i++) {
+        result[columns[i].name] = convertValue(columns[i], rawRow[i], unpack);
+    }
+    return result;
+}
+/**
+ * Convert a single raw value to its Malloy representation,
+ * dispatching to the appropriate converter based on type.
+ * Non-atomic fields (joins, turtles) are passed through as-is.
+ */
+function convertValue(typeDef, raw, unpack) {
+    if (!(0, malloy_1.isAtomic)(typeDef)) {
+        return [];
+    }
+    if (typeDef.type === 'record') {
+        return convertRecord(typeDef.fields, raw, unpack);
+    }
+    if ((0, malloy_1.isRepeatedRecord)(typeDef)) {
+        return convertRepeatedRecord(typeDef.fields, raw, unpack);
+    }
+    if ((0, malloy_1.isBasicArray)(typeDef)) {
+        return convertArray(typeDef.elementTypeDef, raw, unpack);
+    }
+    return convertScalar(typeDef, raw);
+}
+/**
+ * Convert a record (ROW/STRUCT) value: the database returns these
+ * as positional arrays, which we map to named fields. A null
+ * record stays null.
+ */
+function convertRecord(fields, raw, unpack) {
+    if (raw === null || raw === undefined)
+        return null;
+    const values = unpack(raw);
+    const result = {};
+    for (let i = 0; i < fields.length; i++) {
+        result[fields[i].name] = convertValue(fields[i], values[i], unpack);
+    }
+    return result;
+}
+/**
+ * Convert an array of records. This handles both nested Malloy
+ * query results (nest:) and ARRAY<ROW(...)> column values. A null
+ * input becomes [] — for nested queries this correctly represents
+ * "no matching rows."
+ */
+function convertRepeatedRecord(fields, raw, unpack) {
+    if (raw === null || raw === undefined)
+        return [];
+    const rows = unpack(raw);
+    return rows.map(row => convertRecord(fields, row, unpack));
+}
+/**
+ * Convert a basic array (number[], string[], etc.). A null array
+ * stays null. Elements are recursively converted through
+ * convertValue for proper type coercion.
+ */
+function convertArray(elementType, raw, unpack) {
+    if (raw === null || raw === undefined)
+        return null;
+    const values = unpack(raw);
+    return values.map(el => convertValue(elementType, el, unpack));
+}
+/**
+ * Convert a scalar value, handling Trino/Presto wire format quirks:
+ * - Decimal numbers arrive as strings
+ * - Timestamps arrive as strings
+ * - TIMESTAMP WITH TIME ZONE uses "datetime timezone" format
+ * - Dates arrive as strings (e.g. "2020-01-15"), passed through
+ *   for rowDataToDate to handle downstream
+ * - BIGINT precision is limited by the Trino JS client which
+ *   delivers values as JS number (no bigint support)
+ */
+function convertScalar(typeDef, raw) {
+    if (raw === null || raw === undefined)
+        return null;
+    if (typeDef.type === 'number' && typeof raw === 'string') {
+        // Decimals arrive as strings. BIGINT values arrive as JS number
+        // (already lossy for values > MAX_SAFE_INTEGER) so they don't
+        // hit this path — this is only for decimal-as-string coercion.
+        return Number(raw);
+    }
+    if ((typeDef.type === 'timestamp' || typeDef.type === 'timestamptz') &&
+        typeof raw === 'string') {
+        if (typeDef.type === 'timestamptz') {
+            // TIMESTAMP WITH TIME ZONE: "2020-02-20 00:00:00 America/Mexico_City"
+            const trinoTzPattern = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)?) (.+)$/;
+            const match = raw.match(trinoTzPattern);
+            if (match) {
+                const [, dateTimePart, tzName] = match;
+                const dt = luxon_1.DateTime.fromSQL(dateTimePart, { zone: tzName });
+                if (dt.isValid) {
+                    return dt.toJSDate();
+                }
+            }
+        }
+        // Plain timestamps: Trino returns UTC values
+        return new Date(raw + 'Z');
+    }
+    if (typeof raw === 'string' ||
+        typeof raw === 'number' ||
+        typeof raw === 'boolean') {
+        return raw;
+    }
+    return null;
+}
+//# sourceMappingURL=result-to-querydata.js.map

package/dist/trino_connection.d.ts

@@ -18,6 +18,7 @@ export interface TrinoConnectionConfiguration {
     schema?: string;
     user?: string;
     password?: string;
+    setupSQL?: string;
     extraConfig?: Partial<Omit<ConnectionOptions, keyof TrinoConnectionConfiguration>>;
 }
 export type TrinoConnectionOptions = ConnectionConfig;
@@ -39,7 +40,12 @@ export declare abstract class TrinoPrestoConnection extends BaseConnection imple
     private queryOptions?;
     protected readonly dialect: TrinoDialect;
     static DEFAULT_QUERY_OPTIONS: RunSQLOptions;
-    constructor(name: string, client: BaseRunner, queryOptions?: QueryOptionsReader | undefined);
+    protected setupSQL: string | undefined;
+    private setupDone;
+    protected connectionConfig: TrinoConnectionConfiguration;
+    constructor(name: string, client: BaseRunner, queryOptions?: QueryOptionsReader | undefined, setupSQL?: string, connectionConfig?: TrinoConnectionConfiguration);
+    private ensureSetup;
+    private runSetupStatements;
     get dialectName(): string;
     private readQueryOptions;
     canPersist(): this is PersistSQLResults;
@@ -47,10 +53,7 @@ export declare abstract class TrinoPrestoConnection extends BaseConnection imple
     get supportsNesting(): boolean;
     manifestTemporaryTable(_sqlCommand: string): Promise<string>;
     unpackArray(_fields: FieldDef[], data: unknown): unknown[];
-    convertRow(fields: FieldDef[], rawRow: unknown): {};
-    convertNest(fields: FieldDef[], _data: unknown): unknown[];
     runSQL(sqlCommand: string, options?: RunSQLOptions, _rowIndex?: number): Promise<MalloyQueryData>;
-    private resultRow;
     runSQLBlockAndFetchResultSchema(_sqlBlock: SQLSourceDef, _options?: RunSQLOptions): Promise<{
         data: MalloyQueryData;
         schema: StructDef;

package/dist/trino_connection.js

@@ -28,7 +28,7 @@ const connection_1 = require("@malloydata/malloy/connection");
 const presto_js_client_1 = require("@prestodb/presto-js-client");
 const crypto_1 = require("crypto");
 const trino_client_1 = require("trino-client");
-const luxon_1 = require("luxon");
+const result_to_querydata_1 = require("./result-to-querydata");
 class PrestoRunner {
     constructor(config) {
         const prestoClientConfig = {
@@ -115,7 +115,7 @@ class TrinoRunner {
     }
 }
 class TrinoPrestoConnection extends connection_1.BaseConnection {
-    constructor(name, client, queryOptions) {
+    constructor(name, client, queryOptions, setupSQL, connectionConfig) {
         super();
         this.name = name;
         this.client = client;
@@ -123,6 +123,27 @@ class TrinoPrestoConnection extends connection_1.BaseConnection {
         this.dialect = new malloy_1.TrinoDialect();
         this.name = name;
         this.queryOptions = queryOptions;
+        this.setupSQL = setupSQL;
+        this.connectionConfig = connectionConfig !== null && connectionConfig !== void 0 ? connectionConfig : {};
+    }
+    async ensureSetup() {
+        if (!this.setupDone && this.setupSQL) {
+            this.setupDone = this.runSetupStatements();
+        }
+        if (this.setupDone) {
+            await this.setupDone;
+        }
+    }
+    async runSetupStatements() {
+        for (const stmt of this.setupSQL.split(';\n')) {
+            const trimmed = stmt.trim();
+            if (trimmed) {
+                const r = await this.client.runSQL(trimmed, {});
+                if (r.error) {
+                    throw new Error(r.error);
+                }
+            }
+        }
     }
     get dialectName() {
         return this.name;
@@ -145,8 +166,9 @@ class TrinoPrestoConnection extends connection_1.BaseConnection {
         return true;
     }
     getDigest() {
-        const data = `trino:${this.name}`;
-        return (0, malloy_1.makeDigest)(data);
+        var _a;
+        const { server, port, catalog, schema, user } = this.connectionConfig;
+        return (0, malloy_1.makeDigest)('trino', server !== null && server !== void 0 ? server : '', String(port !== null && port !== void 0 ? port : ''), catalog !== null && catalog !== void 0 ? catalog : '', schema !== null && schema !== void 0 ? schema : '', user !== null && user !== void 0 ? user : '', (_a = this.setupSQL) !== null && _a !== void 0 ? _a : '');
     }
     get supportsNesting() {
         return true;
@@ -157,101 +179,21 @@ class TrinoPrestoConnection extends connection_1.BaseConnection {
     unpackArray(_fields, data) {
         return data;
     }
-    convertRow(fields, rawRow) {
-        var _a;
-        const retRow = {};
-        const row = this.unpackArray(fields, rawRow);
-        for (let i = 0; i < fields.length; i++) {
-            const field = fields[i];
-            if (field.type === 'record') {
-                retRow[field.name] = this.convertRow(field.fields, row[i]);
-            }
-            else if ((0, malloy_1.isRepeatedRecord)(field)) {
-                retRow[field.name] = this.convertNest(field.fields, row[i]);
-            }
-            else if ((0, malloy_1.isBasicArray)(field)) {
-                retRow[field.name] = this.unpackArray([], row[i]);
-            }
-            else {
-                retRow[field.name] = (_a = row[i]) !== null && _a !== void 0 ? _a : null;
-            }
-        }
-        //console.log(retRow);
-        return retRow;
-    }
-    convertNest(fields, _data) {
-        const data = this.unpackArray(fields, _data);
-        const ret = [];
-        const rows = (data === null || data === undefined ? [] : data);
-        for (const row of rows) {
-            ret.push(this.convertRow(fields, row));
-        }
-        return ret;
-    }
     async runSQL(sqlCommand, options = {}, 
     // TODO(figutierrez): Use.
     _rowIndex = 0) {
+        await this.ensureSetup();
         const r = await this.client.runSQL(sqlCommand, options);
         if (r.error) {
             throw new Error(r.error);
         }
         const { rows: inputRows, columns, profilingUrl } = r;
         const malloyColumns = columns.map(c => (0, malloy_1.mkFieldDef)(this.malloyTypeFromTrinoType(c.type), c.name));
-        const malloyRows = [];
+        const unpack = (data) => this.unpackArray([], data);
         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];
-                const schemaColumn = malloyColumns[i];
-                malloyRow[column.name] = this.resultRow(schemaColumn, row[i]);
-            }
-            malloyRows.push(malloyRow);
-        }
+        const malloyRows = rows.map(row => (0, result_to_querydata_1.resultRowToQueryRecord)(malloyColumns, row, unpack));
         return { rows: malloyRows, totalRows: malloyRows.length, profilingUrl };
     }
-    resultRow(colSchema, rawRow) {
-        if (colSchema.type === 'record') {
-            return this.convertRow(colSchema.fields, rawRow);
-        }
-        else if ((0, malloy_1.isRepeatedRecord)(colSchema)) {
-            return this.convertNest(colSchema.fields, rawRow);
-        }
-        else if ((0, malloy_1.isBasicArray)(colSchema)) {
-            const elType = colSchema.elementTypeDef;
-            let theArray = this.unpackArray([], rawRow);
-            if (elType.type === 'array') {
-                theArray = theArray.map(el => this.resultRow(elType, el));
-            }
-            return theArray;
-        }
-        else if (colSchema.type === 'number' && typeof rawRow === 'string') {
-            // decimal numbers come back as strings
-            return Number(rawRow);
-        }
-        else if ((colSchema.type === 'timestamp' || colSchema.type === 'timestamptz') &&
-            typeof rawRow === 'string') {
-            // timestamps come back as strings
-            if (colSchema.type === 'timestamptz') {
-                // TIMESTAMP WITH TIME ZONE format: "2020-02-20 00:00:00 America/Mexico_City"
-                const trinoTzPattern = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)?) (.+)$/;
-                const match = rawRow.match(trinoTzPattern);
-                if (match) {
-                    const [, dateTimePart, tzName] = match;
-                    // Use Luxon to parse with timezone awareness
-                    const dt = luxon_1.DateTime.fromSQL(dateTimePart, { zone: tzName });
-                    if (dt.isValid) {
-                        return dt.toJSDate();
-                    }
-                }
-            }
-            // For plain timestamps, Trino returns UTC values - append 'Z' to parse as UTC
-            return new Date(rawRow + 'Z');
-        }
-        else {
-            return rawRow;
-        }
-    }
     async runSQLBlockAndFetchResultSchema(_sqlBlock, _options) {
         throw new Error('Not implemented 3');
     }
@@ -280,6 +222,7 @@ class TrinoPrestoConnection extends connection_1.BaseConnection {
         return structDef;
     }
     async executeAndWait(sqlBlock) {
+        await this.ensureSetup();
         await this.client.runSQL(sqlBlock, {});
         // TODO: make sure failure is handled correctly.
         //while (!(await result.next()).done);
@@ -299,6 +242,7 @@ class TrinoPrestoConnection extends connection_1.BaseConnection {
     async loadSchemaForSqlBlock(sqlBlock, structDef, element) {
         var _a;
         try {
+            await this.ensureSetup();
             const queryResult = await this.client.runSQL(sqlBlock, {});
             if (queryResult.error) {
                 // TODO: handle.
@@ -343,7 +287,12 @@ TrinoPrestoConnection.DEFAULT_QUERY_OPTIONS = {
 };
 class PrestoConnection extends TrinoPrestoConnection {
     constructor(arg, queryOptions, config = {}) {
-        super(typeof arg === 'string' ? arg : arg.name, new PrestoRunner(config), queryOptions);
+        const setupSQL = typeof arg === 'string'
+            ? config.setupSQL
+            : typeof arg['setupSQL'] === 'string'
+                ? arg['setupSQL']
+                : undefined;
+        super(typeof arg === 'string' ? arg : arg.name, new PrestoRunner(config), queryOptions, setupSQL, config);
     }
     get dialectName() {
         return 'presto';
@@ -375,7 +324,12 @@ class PrestoConnection extends TrinoPrestoConnection {
 exports.PrestoConnection = PrestoConnection;
 class TrinoConnection extends TrinoPrestoConnection {
     constructor(arg, queryOptions, config = {}) {
-        super(typeof arg === 'string' ? arg : arg.name, new TrinoRunner(config), queryOptions);
+        const setupSQL = typeof arg === 'string'
+            ? config.setupSQL
+            : typeof arg['setupSQL'] === 'string'
+                ? arg['setupSQL']
+                : undefined;
+        super(typeof arg === 'string' ? arg : arg.name, new TrinoRunner(config), queryOptions, setupSQL, config);
     }
     get dialectName() {
         return 'trino';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-trino",
-  "version": "0.0.337",
+  "version": "0.0.338",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,7 +22,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@malloydata/malloy": "0.0.337",
+    "@malloydata/malloy": "0.0.338",
     "@prestodb/presto-js-client": "^1.0.0",
     "gaxios": "^4.2.0",
     "luxon": "^3.5.0",