@malloydata/malloy 0.0.141-dev240410194001 → 0.0.141

package/dist/dialect/dialect.d.ts

@@ -1,4 +1,4 @@
-import { DialectFragment, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../model/malloy_types';
+import { DialectFragment, Expr, ExtractUnit, Sampling, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../model/malloy_types';
 import { DialectFunctionOverloadDef } from './functions';
 type DialectFieldTypes = string | 'struct';
 interface DialectField {
@@ -52,6 +52,7 @@ export declare abstract class Dialect {
     readsNestedData: boolean;
     orderByClause: OrderByClauseType;
     nullMatchesFunctionSignature: boolean;
+    supportsSelectReplace: boolean;
     abstract getGlobalFunctionDef(name: string): DialectFunctionOverloadDef[] | undefined;
     abstract quoteTablePath(tablePath: string): string;
     abstract sqlGroupSetTable(groupSetCount: number): string;
@@ -66,9 +67,9 @@ export declare abstract class Dialect {
     abstract sqlFieldReference(alias: string, fieldName: string, fieldType: string, isNested: boolean, isArray: boolean): string;
     abstract sqlUnnestPipelineHead(isSingleton: boolean, sourceSQLExpression: string): string;
     abstract sqlCreateFunction(id: string, funcText: string): string;
-    abstract sqlCreateFunctionCombineLastStage(lastStageName: string, structDef: StructDef): string;
+    abstract sqlCreateFunctionCombineLastStage(lastStageName: string, fieldList: DialectFieldList): string;
     abstract sqlCreateTableAsSelect(tableName: string, sql: string): string;
-    abstract sqlSelectAliasAsStruct(alias: string, physicalFieldNames: string[]): string;
+    abstract sqlSelectAliasAsStruct(alias: string, fieldList: DialectFieldList): string;
     sqlFinalStage(_lastStageName: string, _fields: string[]): string;
     sqlDateToString(sqlDateExp: string): string;
     abstract sqlMaybeQuoteIdentifier(identifier: string): string;

package/dist/dialect/dialect.js

@@ -72,6 +72,8 @@ class Dialect {
         this.orderByClause = 'ordinal';
         // null will match in a function signature
         this.nullMatchesFunctionSignature = true;
+        // support select * replace(...)
+        this.supportsSelectReplace = true;
     }
     sqlFinalStage(_lastStageName, _fields) {
         throw new Error('Dialect has no final Stage but called Anyway');

package/dist/dialect/duckdb/duckdb.d.ts

@@ -1,4 +1,4 @@
-import { DateUnit, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../../model/malloy_types';
+import { DateUnit, Expr, ExtractUnit, Sampling, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
 import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
 export declare class DuckDBDialect extends Dialect {
@@ -35,8 +35,8 @@ export declare class DuckDBDialect extends Dialect {
     sqlFieldReference(alias: string, fieldName: string, _fieldType: string, _isNested: boolean, isArray: boolean): string;
     sqlUnnestPipelineHead(isSingleton: boolean, sourceSQLExpression: string): string;
     sqlCreateFunction(id: string, funcText: string): string;
-    sqlCreateFunctionCombineLastStage(lastStageName: string, structDef: StructDef): string;
-    sqlSelectAliasAsStruct(alias: string, physicalFieldNames: string[]): string;
+    sqlCreateFunctionCombineLastStage(lastStageName: string, dialectFieldList: DialectFieldList): string;
+    sqlSelectAliasAsStruct(alias: string, dialectFieldList: DialectFieldList): string;
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
     sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;

package/dist/dialect/duckdb/duckdb.js

@@ -177,14 +177,14 @@ class DuckDBDialect extends dialect_1.Dialect {
     sqlCreateFunction(id, funcText) {
         return `DROP MACRO IF EXISTS ${id}; \n${hackSplitComment}\n CREATE MACRO ${id}(_param) AS (\n${(0, utils_1.indent)(funcText)}\n);\n${hackSplitComment}\n`;
     }
-    sqlCreateFunctionCombineLastStage(lastStageName, structDef) {
-        return `SELECT LIST(STRUCT_PACK(${structDef.fields
-            .map(fieldDef => this.sqlMaybeQuoteIdentifier((0, malloy_types_1.getIdentifier)(fieldDef)))
+    sqlCreateFunctionCombineLastStage(lastStageName, dialectFieldList) {
+        return `SELECT LIST(STRUCT_PACK(${dialectFieldList
+            .map(d => this.sqlMaybeQuoteIdentifier(d.sqlOutputName))
             .join(',')})) FROM ${lastStageName}\n`;
     }
-    sqlSelectAliasAsStruct(alias, physicalFieldNames) {
-        return `STRUCT_PACK(${physicalFieldNames
-            .map(name => `${alias}.${name}`)
+    sqlSelectAliasAsStruct(alias, dialectFieldList) {
+        return `STRUCT_PACK(${dialectFieldList
+            .map(d => `${alias}.${d.sqlOutputName}`)
             .join(', ')})`;
     }
     // TODO

package/dist/dialect/trino/trino.d.ts

@@ -23,6 +23,7 @@ export declare class TrinoDialect extends Dialect {
     cantPartitionWindowFunctionsOnExpressions: boolean;
     orderByClause: OrderByClauseType;
     nullMatchesFunctionSignature: boolean;
+    supportsSelectReplace: boolean;
     quoteTablePath(tablePath: string): string;
     sqlGroupSetTable(groupSetCount: number): string;
     dialectExpr(qi: QueryInfo, df: DialectFragment): Expr;
@@ -39,8 +40,8 @@ export declare class TrinoDialect extends Dialect {
     sqlUnnestPipelineHead(isSingleton: boolean, sourceSQLExpression: string): string;
     sqlCreateFunction(id: string, funcText: string): string;
     sqlCreateTableAsSelect(tableName: string, sql: string): string;
-    sqlCreateFunctionCombineLastStage(lastStageName: string): string;
-    sqlSelectAliasAsStruct(alias: string): string;
+    sqlCreateFunctionCombineLastStage(lastStageName: string, fieldList: DialectFieldList): string;
+    sqlSelectAliasAsStruct(alias: string, fieldList: any): string;
     keywords: string[];
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlNow(): Expr;

package/dist/dialect/trino/trino.js

@@ -77,6 +77,7 @@ class TrinoDialect extends dialect_1.Dialect {
         this.cantPartitionWindowFunctionsOnExpressions = false;
         this.orderByClause = 'output_name';
         this.nullMatchesFunctionSignature = false;
+        this.supportsSelectReplace = false;
         // TODO(figutierrez): update.
         this.keywords = `
   ALL
@@ -279,7 +280,7 @@ class TrinoDialect extends dialect_1.Dialect {
     sqlUnnestPipelineHead(isSingleton, sourceSQLExpression) {
         let p = sourceSQLExpression;
         if (isSingleton) {
-            p = `[${p}]`;
+            p = `ARRAY[${p}]`;
         }
         return `UNNEST(${p})`;
     }
@@ -297,11 +298,15 @@ ${(0, utils_1.indent)(sql)}
 );
 `;
     }
-    sqlCreateFunctionCombineLastStage(lastStageName) {
-        return `SELECT ARRAY((SELECT AS STRUCT * FROM ${lastStageName}))\n`;
+    sqlCreateFunctionCombineLastStage(lastStageName, fieldList) {
+        const fields = fieldList.map(f => f.sqlExpression).join(', ');
+        const definitions = this.buildTypeExpression(fieldList);
+        return `SELECT ARRAY_AGG(CAST(ROW(${fields}) as ROW(${definitions}))) FROM ${lastStageName}\n`;
     }
-    sqlSelectAliasAsStruct(alias) {
-        return `(SELECT AS STRUCT ${alias}.*)`;
+    sqlSelectAliasAsStruct(alias, fieldList) {
+        const fields = fieldList.map(f => f.sqlExpression).join(', ');
+        const definitions = this.buildTypeExpression(fieldList);
+        return `CAST(ROW(${fields}) as ROW(${definitions})`;
     }
     sqlMaybeQuoteIdentifier(identifier) {
         return '"' + identifier + '"';

package/dist/model/malloy_query.js

@@ -37,6 +37,18 @@ function generateSQLStringLiteral(sourceString) {
 function identifierNormalize(s) {
     return s.replace(/[^a-zA-Z0-9_]/g, '_o_');
 }
+function getDialectFieldList(structDef) {
+    const dialectFieldList = [];
+    for (const f of structDef.fields.filter(malloy_types_1.isPhysical)) {
+        dialectFieldList.push({
+            type: f.type,
+            sqlExpression: (0, malloy_types_1.getIdentifier)(f),
+            rawName: (0, malloy_types_1.getIdentifier)(f),
+            sqlOutputName: (0, malloy_types_1.getIdentifier)(f),
+        });
+    }
+    return dialectFieldList;
+}
 class UniqueKeyUse extends Set {
     add_use(k) {
         if (k !== undefined) {
@@ -86,7 +98,7 @@ class StageWriter {
         if (lastStageName === undefined) {
             throw new Error('Internal Error: no stage to combine');
         }
-        sql += dialect.sqlCreateFunctionCombineLastStage(lastStageName, structDef);
+        sql += dialect.sqlCreateFunctionCombineLastStage(lastStageName, getDialectFieldList(structDef));
         const id = `${dialect.udfPrefix}${this.root().udfs.length}`;
         sql = dialect.sqlCreateFunction(id, sql);
         this.root().udfs.push(sql);
@@ -131,11 +143,11 @@ class StageWriter {
     }
     generateCoorelatedSubQuery(dialect, structDef) {
         if (!this.useCTE) {
-            return dialect.sqlCreateFunctionCombineLastStage(`(${this.withs[0]})`, structDef);
+            return dialect.sqlCreateFunctionCombineLastStage(`(${this.withs[0]})`, getDialectFieldList(structDef));
         }
         else {
             return (this.combineStages(true).sql +
-                dialect.sqlCreateFunctionCombineLastStage(this.getName(this.withs.length - 1), structDef));
+                dialect.sqlCreateFunctionCombineLastStage(this.getName(this.withs.length - 1), getDialectFieldList(structDef)));
         }
     }
 }
@@ -1421,16 +1433,7 @@ class JoinInstance {
     }
     // postgres unnest needs to know the names of the physical fields.
     getDialectFieldList() {
-        const dialectFieldList = [];
-        for (const f of this.queryStruct.fieldDef.fields.filter(malloy_types_1.isPhysical)) {
-            dialectFieldList.push({
-                type: f.type,
-                sqlExpression: (0, malloy_types_1.getIdentifier)(f),
-                rawName: (0, malloy_types_1.getIdentifier)(f),
-                sqlOutputName: (0, malloy_types_1.getIdentifier)(f),
-            });
-        }
-        return dialectFieldList;
+        return getDialectFieldList(this.queryStruct.fieldDef);
     }
 }
 /** nested query */
@@ -1996,8 +1999,7 @@ class QueryQuery extends QueryField {
                 let joins = '';
                 for (const childJoin of ji.children) {
                     joins += this.generateSQLJoinBlock(stageWriter, childJoin);
-                    const physicalFields = (0, malloy_types_1.getPhysicalFields)(childJoin.queryStruct.fieldDef).map(fieldDef => this.parent.dialect.sqlMaybeQuoteIdentifier(fieldDef.name));
-                    select += `, ${this.parent.dialect.sqlSelectAliasAsStruct(childJoin.alias, physicalFields)} AS ${childJoin.alias}`;
+                    select += `, ${this.parent.dialect.sqlSelectAliasAsStruct(childJoin.alias, getDialectFieldList(childJoin.queryStruct.fieldDef))} AS ${childJoin.alias}`;
                 }
                 select += `\nFROM ${structSQL} AS ${ji.alias}\n${joins}\nWHERE ${conditions === null || conditions === void 0 ? void 0 : conditions.join(' AND ')}\n`;
                 s += `${matrixOperation} JOIN (\n${(0, utils_1.indent)(select)}) AS ${ji.alias}\n  ON ${onCondition}\n`;
@@ -2170,12 +2172,24 @@ class QueryQuery extends QueryField {
         if (outputPipelinedSQL.length === 0) {
             return lastStageName;
         }
-        const pipelinesSQL = outputPipelinedSQL
-            .map(o => `${o.pipelineSQL} as ${o.sqlFieldName}
-      `)
-            .join(',\n');
-        return stageWriter.addStage(`SELECT * replace (${pipelinesSQL}) FROM ${lastStageName}
-      `);
+        let retSQL;
+        if (this.parent.dialect.supportsSelectReplace) {
+            const pipelinesSQL = outputPipelinedSQL
+                .map(o => `${o.pipelineSQL} as ${o.sqlFieldName}`)
+                .join(',\n');
+            retSQL = `SELECT * replace (${pipelinesSQL}) FROM ${lastStageName}
+        `;
+        }
+        else {
+            const pipelinesSQL = outputPipelinedSQL
+                .map(o => `${o.pipelineSQL} as ${o.sqlFieldName}`)
+                .join(',\n');
+            const outputFields = outputPipelinedSQL.map(f => f.sqlFieldName);
+            const allFields = Array.from(this.rootResult.allFields.keys()).map(f => this.parent.dialect.sqlMaybeQuoteIdentifier(f));
+            const fields = allFields.filter(f => outputFields.indexOf(f) === -1);
+            retSQL = `SELECT ${fields.length > 0 ? fields.join(', ') + ',' : ''} ${pipelinesSQL} FROM ${lastStageName}`;
+        }
+        return stageWriter.addStage(retSQL);
     }
     generateStage0Fields(resultSet, output, stageWriter) {
         const scalarFields = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.141-dev240410194001",
+  "version": "0.0.141",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",