@malloydata/db-trino 0.0.138-dev240403210124 → 0.0.138-dev240404145618

package/dist/trino_connection.d.ts

@@ -38,8 +38,8 @@ export declare class TrinoConnection implements Connection, PersistSQLResults {
     canStream(): this is StreamingConnection;
     get supportsNesting(): boolean;
     manifestTemporaryTable(_sqlCommand: string): Promise<string>;
-    convertRow(structDef: StructDef, row: unknown[]): {};
-    convertNest(structDef: StructDef, dataRows: unknown[][]): {};
+    convertRow(structDef: StructDef, _row: unknown): {};
+    convertNest(structDef: StructDef, data: unknown): {};
     runSQL(sqlCommand: string, options?: RunSQLOptions, _rowIndex?: number): Promise<MalloyQueryData>;
     runSQLBlockAndFetchResultSchema(_sqlBlock: SQLBlock, _options?: RunSQLOptions): Promise<{
         data: MalloyQueryData;

package/dist/trino_connection.js

@@ -166,20 +166,36 @@ class TrinoConnection {
         throw maybeRewriteError(e);
       }
     }*/
-    convertRow(structDef, row) {
-        const col = {};
+    convertRow(structDef, _row) {
+        const retRow = {};
+        const row = _row;
         for (let i = 0; i < structDef.fields.length; i++) {
-            col[structDef.fields[i].name] = row[i] === undefined ? null : row[i];
+            const field = structDef.fields[i];
+            if (field.type === 'struct') {
+                const struct = field;
+                if (struct.structSource.type === 'inline') {
+                    retRow[field.name] = this.convertRow(struct, row[i]);
+                }
+                else {
+                    retRow[field.name] = this.convertNest(struct, row[i]);
+                }
+            }
+            else {
+                retRow[field.name] = row[i] === undefined ? null : row[i];
+            }
         }
-        return col;
+        //console.log(retRow);
+        return retRow;
     }
-    convertNest(structDef, dataRows) {
-        const rows = dataRows === null || dataRows === undefined ? [] : dataRows;
+    convertNest(structDef, data) {
         const ret = [];
-        if (structDef.structRelationship.type === 'nested' &&
-            !structDef.structRelationship.isArray) {
-            return this.convertRow(structDef, rows);
+        //console.log(
+        //   `${JSON.stringify(structDef, null, 2)} ${JSON.stringify(data, null, 2)} `
+        // );
+        if (structDef.structSource.type === 'inline') {
+            return this.convertRow(structDef, data);
         }
+        const rows = (data === null || data === undefined ? [] : data);
         for (const row of rows) {
             ret.push(this.convertRow(structDef, row));
         }
@@ -210,7 +226,19 @@ class TrinoConnection {
                 for (let i = 0; i < queryResult.value.columns.length; i++) {
                     const column = queryResult.value.columns[i];
                     if (malloyColumns[i].type === 'struct') {
-                        malloyRow[column.name] = this.convertNest(malloyColumns[i], row[i]);
+                        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 {
                         malloyRow[column.name] = row[i];
@@ -377,14 +405,16 @@ class TrinoConnection {
         var _a;
         let malloyType;
         // Arrays look like `array(type)`
-        const arrayMatch = trinoType.match(/^array\((.*)\)$/);
+        const arrayMatch = trinoType.match(/^(([^,])+\s)?array\((.*)\)$/);
+        // console.log(`${trinoType} arrayMatch: ${arrayMatch}`);
         // Structs look like `row(name type, name type)`
-        const structMatch = trinoType.match(/^row\((.*)\)$/);
+        const structMatch = trinoType.match(/^(([^,])+\s)?row\((.*)\)$/);
+        // console.log(`${trinoType} structMatch: ${structMatch}`);
         if (arrayMatch) {
-            const arrayType = arrayMatch[1];
+            const arrayType = arrayMatch[3];
             const innerType = this.malloyTypeFromTrinoType(name, arrayType);
             if (innerType.type === 'struct') {
-                malloyType = innerType;
+                malloyType = { ...innerType, structSource: { type: 'nested' } };
                 malloyType.structRelationship = {
                     type: 'nested',
                     fieldName: name,
@@ -410,16 +440,15 @@ class TrinoConnection {
             // TODO: Trino doesn't quote or escape commas in field names,
             // so some magic is going to need to be applied before we get here
             // to avoid confusion if a field name contains a comma
-            const innerTypes = this.splitColumns(structMatch[1]);
+            const innerTypes = this.splitColumns(structMatch[3]);
+            // console.log(`innerType: ${JSON.stringify(innerTypes)}`);
             malloyType = {
                 type: 'struct',
                 name,
                 dialect: this.dialectName,
-                structSource: { type: 'nested' },
+                structSource: { type: 'inline' },
                 structRelationship: {
-                    type: 'nested',
-                    fieldName: name,
-                    isArray: false,
+                    type: 'inline',
                 },
                 fields: [],
             };
@@ -427,7 +456,10 @@ class TrinoConnection {
                 // TODO: Handle time zone type annotation, which is an
                 // exception to the types not containing spaces assumption
                 innerType = innerType.replace(/ with time zone$/, '');
-                const parts = innerType.match(/^(.*)\s(\S+)$/);
+                let parts = innerType.match(/^(.*)\s((array\(|row\().*)$/);
+                if (parts === null) {
+                    parts = innerType.match(/^(.*)\s(\S+)$/);
+                }
                 if (parts) {
                     const innerName = parts[1];
                     const innerTrinoType = parts[2];
@@ -449,6 +481,7 @@ class TrinoConnection {
                 rawType: trinoType.toLowerCase(),
             };
         }
+        // console.log('>', trinoType, '\n<', malloyType);
         return malloyType;
     }
     structDefFromSchema(rows, structDef) {

package/dist/trino_connection.spec.js

@@ -23,9 +23,12 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const _1 = require(".");
+// Array(varchar) is array
 const ARRAY_SCHEMA = 'array(integer)';
-const STRUCT_SCHEMA = 'row(a double, b integer, c varchar(60))';
-const DEEP_SCHEMA = 'array(row(a double, b integer, c varchar(60)))';
+// Row(...) is inline
+const INLINE_SCHEMA = 'row(a double, b integer, c varchar(60))';
+// Array(row(....)) is nested
+const NESTED_SCHEMA = 'array(row(a double, b integer, c varchar(60)))';
 describe('Trino connection', () => {
     let connection;
     beforeAll(() => {
@@ -57,19 +60,16 @@ describe('Trino connection', () => {
                 ],
             });
         });
-        it('parses structs', () => {
-            const connection = new _1.TrinoConnection('trino', {}, _1.TrinoExecutor.getConnectionOptionsFromEnv());
-            expect(connection.malloyTypeFromTrinoType('test', STRUCT_SCHEMA)).toEqual({
+        it('parses inline', () => {
+            expect(connection.malloyTypeFromTrinoType('test', INLINE_SCHEMA)).toEqual({
                 'name': 'test',
                 'type': 'struct',
                 'dialect': 'trino',
                 'structRelationship': {
-                    'fieldName': 'test',
-                    'isArray': false,
-                    'type': 'nested',
+                    'type': 'inline',
                 },
                 'structSource': {
-                    'type': 'nested',
+                    'type': 'inline',
                 },
                 'fields': [
                     {
@@ -89,9 +89,8 @@ describe('Trino connection', () => {
                 ],
             });
         });
-        it('parses arrays of structs', () => {
-            const connection = new _1.TrinoConnection('trino', {}, _1.TrinoExecutor.getConnectionOptionsFromEnv());
-            expect(connection.malloyTypeFromTrinoType('test', DEEP_SCHEMA)).toEqual({
+        it('parses nested', () => {
+            expect(connection.malloyTypeFromTrinoType('test', NESTED_SCHEMA)).toEqual({
                 'name': 'test',
                 'type': 'struct',
                 'dialect': 'trino',
@@ -108,6 +107,11 @@ describe('Trino connection', () => {
                 ],
             });
         });
+        it('parses a simple type', () => {
+            expect(connection.malloyTypeFromTrinoType('test', 'varchar(60)')).toEqual({
+                'type': 'string',
+            });
+        });
     });
     describe('splitColumns', () => {
         it('handles internal rows', () => {

package/package.json

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