@malloydata/malloy 0.0.177-dev240828173040 → 0.0.177-dev240829030921

package/dist/model/malloy_query.js

@@ -235,7 +235,7 @@ class QueryField extends QueryNode {
         // find the structDef and return the path to the field...
         const field = context.getFieldByName(expr.path);
         if ((0, malloy_types_1.hasExpression)(field.fieldDef)) {
-            const ret = this.generateExpressionFromExpr(resultSet, field.parent, field.fieldDef.e, state);
+            const ret = this.exprToSQL(resultSet, field.parent, field.fieldDef.e, state);
             // in order to avoid too many parens, there was some code here ..
             // if (!ret.match(/^\(.*\)$/)) {
             //   ret = `(${ret})`;
@@ -253,8 +253,19 @@ class QueryField extends QueryNode {
     generateOutputFieldFragment(resultSet, _context, frag, _state) {
         return `(${resultSet.getField(frag.name).getAnalyticalSQL(false)})`;
     }
-    generateSQLExpression(resultSet, context, frag, state) {
-        return this.generateExpressionFromExpr(resultSet, context, frag.e, state);
+    *stringsFromSQLExpression(resultSet, context, e, state) {
+        /*
+         * Like template strings, the array of strings is paired with template insertions,
+         * each string is followed by at most one expression to be inserted
+         */
+        const subExprList = [...e.kids.args];
+        for (const str of e.src) {
+            yield str;
+            const expr = subExprList.shift();
+            if (expr) {
+                yield this.exprToSQL(resultSet, context, expr, state);
+            }
+        }
     }
     getParameterMap(overload, numArgs) {
         return new Map(overload.params.map((param, paramIndex) => {
@@ -265,53 +276,61 @@ class QueryField extends QueryNode {
         }));
     }
     expandFunctionCall(dialect, overload, args, orderBy, limit) {
+        function withCommas(es) {
+            const ret = [];
+            for (let i = 0; i < es.length;) {
+                ret.push(es[i]);
+                i += 1;
+                if (i < es.length) {
+                    ret.push(',');
+                }
+            }
+            return ret;
+        }
         const paramMap = this.getParameterMap(overload, args.length);
         if (overload.dialect[dialect] === undefined) {
-            throw new Error(`Function is not defined for dialect ${dialect}`);
+            throw new Error(`Function is not defined for '${dialect}' dialect`);
         }
-        return (0, utils_1.exprMap)(overload.dialect[dialect].e, fragment => {
+        const expanded = (0, utils_1.exprMap)(overload.dialect[dialect].e, fragment => {
             var _a, _b;
-            if (typeof fragment === 'string') {
-                return [fragment];
-            }
-            else if (fragment.type === 'spread') {
-                const param = fragment.e[0];
-                if (fragment.e.length !== 1 ||
-                    typeof param === 'string' ||
-                    param.type !== 'function_parameter') {
+            if (fragment.node === 'spread') {
+                const param = fragment.e;
+                if (param.node !== 'function_parameter') {
                     throw new Error('Invalid function definition. Argument to spread must be a function parameter.');
                 }
                 const entry = paramMap.get(param.name);
                 if (entry === undefined) {
-                    return [fragment];
-                }
-                else {
-                    return (0, utils_1.joinWith)(entry.argIndexes.map(argIndex => args[argIndex]), ',');
+                    return fragment;
                 }
+                const spread = entry.argIndexes.map(argIndex => args[argIndex]);
+                return (0, utils_1.composeSQLExpr)(withCommas(spread));
             }
-            else if (fragment.type === 'function_parameter') {
+            else if (fragment.node === 'function_parameter') {
                 const entry = paramMap.get(fragment.name);
                 if (entry === undefined) {
-                    return [fragment];
+                    return fragment;
                 }
                 else if (entry.param.isVariadic) {
-                    const spread = (0, utils_1.joinWith)(entry.argIndexes.map(argIndex => args[argIndex]), ',');
-                    return ['[', ...spread, ']'];
+                    const spread = entry.argIndexes.map(argIndex => args[argIndex]);
+                    return (0, utils_1.composeSQLExpr)(withCommas(spread));
                 }
                 else {
                     return args[entry.argIndexes[0]];
                 }
             }
-            else if (fragment.type === 'aggregate_order_by') {
+            else if (fragment.node === 'aggregate_order_by') {
                 return orderBy
-                    ? [` ${(_a = fragment.prefix) !== null && _a !== void 0 ? _a : ''}${orderBy}${(_b = fragment.suffix) !== null && _b !== void 0 ? _b : ''}`]
-                    : [];
+                    ? (0, utils_1.composeSQLExpr)([
+                        ` ${(_a = fragment.prefix) !== null && _a !== void 0 ? _a : ''}${orderBy}${(_b = fragment.suffix) !== null && _b !== void 0 ? _b : ''}`,
+                    ])
+                    : { node: '' };
             }
-            else if (fragment.type === 'aggregate_limit') {
-                return limit ? [` ${limit}`] : [];
+            else if (fragment.node === 'aggregate_limit') {
+                return limit ? (0, utils_1.composeSQLExpr)([` ${limit}`]) : { node: '' };
             }
-            return [fragment];
+            return fragment;
         });
+        return expanded;
     }
     getFunctionOrderBy(resultSet, context, state, orderBy, args, overload) {
         if (orderBy.length === 0)
@@ -319,9 +338,9 @@ class QueryField extends QueryNode {
         return ('ORDER BY ' +
             orderBy
                 .map(ob => {
-                var _a, _b;
+                var _a;
                 const defaultOrderByArgIndex = (_a = overload.dialect[context.dialect.name].defaultOrderByArgIndex) !== null && _a !== void 0 ? _a : 0;
-                const expr = (_b = ob.e) !== null && _b !== void 0 ? _b : args[defaultOrderByArgIndex];
+                const expr = ob.node === 'functionOrderBy' ? ob.e : args[defaultOrderByArgIndex];
                 const osql = this.generateDimFragment(resultSet, context, expr, state);
                 const dirsql = ob.dir === 'asc' ? ' ASC' : ob.dir === 'desc' ? ' DESC' : '';
                 return `${osql}${dirsql}`;
@@ -345,7 +364,7 @@ class QueryField extends QueryNode {
     generateFunctionCallExpression(resultSet, context, frag, state) {
         var _a, _b, _c;
         const overload = frag.overload;
-        const args = frag.args;
+        const args = frag.kids.args;
         const isSymmetric = (_a = frag.overload.isSymmetric) !== null && _a !== void 0 ? _a : false;
         const distinctKey = (0, malloy_types_1.expressionIsAggregate)(overload.returnType.expressionType) &&
             !isSymmetric &&
@@ -355,7 +374,7 @@ class QueryField extends QueryNode {
             distinctKey &&
             !context.dialect.supportsAggDistinct &&
             context.dialect.name !== 'snowflake') {
-            return this.generateAsymmetricStringAggExpression(resultSet, context, args[0], args[1], distinctKey, frag.orderBy, context.dialect.name, state);
+            return this.generateAsymmetricStringAggExpression(resultSet, context, args[0], args[1], distinctKey, frag.kids.orderBy, context.dialect.name, state);
         }
         if (distinctKey) {
             if (!context.dialect.supportsAggDistinct) {
@@ -364,11 +383,11 @@ class QueryField extends QueryNode {
             const argsExpressions = args.map(arg => {
                 return this.generateDimFragment(resultSet, context, arg, state);
             });
-            const orderBys = (_b = frag.orderBy) !== null && _b !== void 0 ? _b : [];
+            const orderBys = (_b = frag.kids.orderBy) !== null && _b !== void 0 ? _b : [];
             const orderByExpressions = orderBys.map(ob => {
-                var _a, _b;
+                var _a;
                 const defaultOrderByArgIndex = (_a = overload.dialect[context.dialect.name].defaultOrderByArgIndex) !== null && _a !== void 0 ? _a : 0;
-                const expr = (_b = ob.e) !== null && _b !== void 0 ? _b : args[defaultOrderByArgIndex];
+                const expr = ob.node === 'functionOrderBy' ? ob.e : args[defaultOrderByArgIndex];
                 return this.generateDimFragment(resultSet, context, expr, state);
             });
             return context.dialect.sqlAggDistinct(distinctKey, [...argsExpressions, ...orderByExpressions], valNames => {
@@ -382,17 +401,17 @@ class QueryField extends QueryNode {
                             return args[i];
                         }
                     }
-                    return [v];
+                    return (0, utils_1.composeSQLExpr)([v]);
                 });
                 const newArgs = vals.slice(0, argsExpressions.length);
                 const orderBy = vals
                     .slice(argsExpressions.length)
                     .map((e, i) => {
-                    return { e, dir: orderBys[i].dir };
+                    return { node: 'functionOrderBy', e, dir: orderBys[i].dir };
                 });
                 const orderBySQL = this.getFunctionOrderBy(resultSet, context, state, orderBy, newArgs, overload);
                 const funcCall = this.expandFunctionCall(context.dialect.name, overload, newArgs, orderBySQL, aggregateLimit);
-                return this.generateExpressionFromExpr(resultSet, context, funcCall, state);
+                return this.exprToSQL(resultSet, context, funcCall, state);
             });
         }
         else {
@@ -413,11 +432,13 @@ class QueryField extends QueryNode {
                     // fragment.
                     return param.allowedTypes.every(t => (0, malloy_types_1.isLiteral)(t.evalSpace))
                         ? arg
-                        : [this.generateDimFragment(resultSet, context, arg, state)];
+                        : (0, utils_1.composeSQLExpr)([
+                            this.generateDimFragment(resultSet, context, arg, state),
+                        ]);
                 })
                 : args;
-            const orderBySql = frag.orderBy
-                ? this.getFunctionOrderBy(resultSet, context, state, frag.orderBy, args, overload)
+            const orderBySql = frag.kids.orderBy
+                ? this.getFunctionOrderBy(resultSet, context, state, frag.kids.orderBy, args, overload)
                 : '';
             const funcCall = this.expandFunctionCall(context.dialect.name, overload, mappedArgs, orderBySql, aggregateLimit);
             if ((0, malloy_types_1.expressionIsAnalytic)(overload.returnType.expressionType)) {
@@ -426,7 +447,7 @@ class QueryField extends QueryNode {
                 });
                 return this.generateAnalyticFragment(resultSet, context, funcCall, overload, state, args, extraPartitions, orderBySql);
             }
-            return this.generateExpressionFromExpr(resultSet, context, funcCall, state);
+            return this.exprToSQL(resultSet, context, funcCall, state);
         }
     }
     generateSpread(_resultSet, _context, _frag, _state) {
@@ -436,19 +457,19 @@ class QueryField extends QueryNode {
         const name = expr.path[0];
         const argument = context.arguments()[name];
         if (argument.value) {
-            return this.generateExpressionFromExpr(resultSet, context, argument.value, state);
+            return this.exprToSQL(resultSet, context, argument.value, state);
         }
         throw new Error(`Can't generate SQL, no value for ${expr.path}`);
     }
     generateFilterFragment(resultSet, context, expr, state) {
         const allWhere = new utils_1.AndChain(state.whereSQL);
-        for (const cond of expr.filterList) {
-            allWhere.add(this.generateExpressionFromExpr(resultSet, context, cond.expression, state.withWhere()));
+        for (const cond of expr.kids.filterList) {
+            allWhere.add(this.exprToSQL(resultSet, context, cond.e, state.withWhere()));
         }
-        return this.generateExpressionFromExpr(resultSet, context, expr.e, state.withWhere(allWhere.sql()));
+        return this.exprToSQL(resultSet, context, expr.kids.e, state.withWhere(allWhere.sql()));
     }
     generateDimFragment(resultSet, context, expr, state) {
-        let dim = this.generateExpressionFromExpr(resultSet, context, expr, state);
+        let dim = this.exprToSQL(resultSet, context, expr, state);
         if (state.whereSQL) {
             dim = `CASE WHEN ${state.whereSQL} THEN ${dim} END`;
         }
@@ -461,7 +482,7 @@ class QueryField extends QueryNode {
         let totalGroupSet;
         let ungroupSet;
         if (expr.fields && expr.fields.length > 0) {
-            const key = expr.fields.sort().join('|') + expr.type;
+            const key = expr.fields.sort().join('|') + expr.node;
             ungroupSet = resultSet.ungroupedSets.get(key);
             if (ungroupSet === undefined) {
                 throw new Error(`Internal Error, cannot find groupset with key ${key}`);
@@ -471,7 +492,7 @@ class QueryField extends QueryNode {
         else {
             totalGroupSet = resultSet.parent ? resultSet.parent.groupSet : 0;
         }
-        const s = this.generateExpressionFromExpr(resultSet, context, expr.e, state.withTotal(totalGroupSet));
+        const s = this.exprToSQL(resultSet, context, expr.e, state.withTotal(totalGroupSet));
         const fields = resultSet.getUngroupPartitions(ungroupSet);
         let partitionBy = '';
         const fieldsString = fields.map(f => f.getAnalyticalSQL(true)).join(', ');
@@ -511,9 +532,7 @@ class QueryField extends QueryNode {
     }
     generateSymmetricFragment(resultSet, context, expr, state) {
         const dimSQL = this.generateDimFragment(resultSet, context, expr.e, state);
-        const f = expr.function === 'count_distinct'
-            ? 'count(distinct '
-            : expr.function + '(';
+        const f = expr.function === 'distinct' ? 'count(distinct ' : expr.function + '(';
         return `${f}${dimSQL})`;
     }
     generateAvgFragment(resultSet, context, expr, state) {
@@ -573,16 +592,6 @@ class QueryField extends QueryNode {
             return `${func}${thing})`;
         }
     }
-    generateDialect(resultSet, context, expr, state) {
-        return this.generateExpressionFromExpr(resultSet, context, context.dialect.dialectExpr(resultSet.getQueryInfo(), expr), state);
-    }
-    generateSqlString(resultSet, context, expr, state) {
-        return expr.e
-            .map(part => typeof part === 'string'
-            ? part
-            : this.generateExpressionFromExpr(resultSet, context, [part], state))
-            .join('');
-    }
     generateSourceReference(resultSet, context, expr) {
         if (expr.path === undefined) {
             return context.getSQLIdentifier();
@@ -666,44 +675,85 @@ class QueryField extends QueryNode {
                 }
                 const argIndex = overload.params.findIndex(param => param.name === value);
                 const arg = args[argIndex];
-                if (arg.length !== 1 ||
-                    typeof arg[0] === 'string' ||
-                    arg[0].type !== 'dialect' ||
-                    arg[0].function !== 'numberLiteral') {
+                if (arg.node !== 'numberLiteral') {
                     throw new Error('Invalid number of rows for window spec');
                 }
                 // TODO this does not handle float literals correctly
-                return arg[0].literal;
+                return arg.literal;
             });
             between = `ROWS BETWEEN ${preceding} PRECEDING AND ${following} FOLLOWING`;
         }
-        const funcSQL = this.generateExpressionFromExpr(resultStruct, context, expr, state);
+        const funcSQL = this.exprToSQL(resultStruct, context, expr, state);
         let retExpr = `${funcSQL} OVER(${partitionBy} ${orderBy} ${between})`;
         if (isComplex) {
             retExpr = `CASE WHEN group_set=${resultStruct.groupSet} THEN ${retExpr} END`;
         }
         return retExpr;
     }
-    generateExpressionFromExpr(resultSet, context, e, state = new GenerateState()) {
-        let s = '';
-        for (const expr of e) {
-            if (typeof expr === 'string') {
-                s += expr;
-            }
-            else if ((0, malloy_types_1.isFieldFragment)(expr)) {
-                s += this.generateFieldFragment(resultSet, context, expr, state);
-            }
-            else if ((0, malloy_types_1.isParameterFragment)(expr)) {
-                s += this.generateParameterFragment(resultSet, context, expr, state);
-            }
-            else if ((0, malloy_types_1.isFilterFragment)(expr)) {
-                s += this.generateFilterFragment(resultSet, context, expr, state);
-            }
-            else if ((0, malloy_types_1.isUngroupFragment)(expr)) {
-                s += this.generateUngroupedFragment(resultSet, context, expr, state);
+    generatePickSQL(pf) {
+        const caseStmt = ['CASE'];
+        for (let i = 0; i < pf.kids.pickWhen.length; i += 1) {
+            caseStmt.push(`WHEN ${pf.kids.pickWhen[i].sql} THEN ${pf.kids.pickThen[i].sql}`);
+        }
+        caseStmt.push(`ELSE ${pf.kids.pickElse.sql}`, 'END');
+        return caseStmt.join(' ');
+    }
+    exprToSQL(resultSet, context, exprToTranslate, state = new GenerateState()) {
+        // Wrap non leaf sub expressions in parenthesis
+        const subExpr = function (qf, e) {
+            const sql = qf.exprToSQL(resultSet, context, e, state);
+            if ((0, malloy_types_1.exprHasKids)(e)) {
+                return `(${sql})`;
             }
-            else if ((0, malloy_types_1.isAggregateFragment)(expr)) {
-                let agg;
+            return sql;
+        };
+        /*
+         * Translate the children first, and stash the translation
+         * in the nodes themselves, so that if we call into the dialect
+         * it will have access to the translated children.
+         */
+        let expr = exprToTranslate;
+        if ((0, malloy_types_1.exprHasE)(exprToTranslate)) {
+            expr = { ...exprToTranslate };
+            const eSql = subExpr(this, expr.e);
+            expr.e = { ...expr.e, sql: eSql };
+        }
+        else if ((0, malloy_types_1.exprHasKids)(exprToTranslate)) {
+            expr = { ...exprToTranslate };
+            const oldKids = exprToTranslate.kids;
+            for (const [name, kidExpr] of Object.entries(oldKids)) {
+                if (Array.isArray(kidExpr)) {
+                    expr.kids[name] = kidExpr.map(e => {
+                        return { ...e, sql: subExpr(this, e) };
+                    });
+                }
+                else {
+                    expr.kids[name] = { ...oldKids[name], sql: subExpr(this, kidExpr) };
+                }
+            }
+        }
+        /*
+         * Give the dialect a chance to translate this node
+         */
+        const qi = resultSet.getQueryInfo();
+        const dialectSQL = this.parent.dialect.exprToSQL(qi, expr);
+        if (dialectSQL) {
+            return dialectSQL;
+        }
+        switch (expr.node) {
+            case 'field':
+                return this.generateFieldFragment(resultSet, context, expr, state);
+            case 'parameter':
+                return this.generateParameterFragment(resultSet, context, expr, state);
+            case 'filteredExpr':
+                return this.generateFilterFragment(resultSet, context, expr, state);
+            case 'all':
+            case 'exclude':
+                return this.generateUngroupedFragment(resultSet, context, expr, state);
+            case 'genericSQLExpr':
+                return Array.from(this.stringsFromSQLExpression(resultSet, context, expr, state)).join('');
+            case 'aggregate': {
+                let agg = '';
                 if (expr.function === 'sum') {
                     agg = this.generateSumFragment(resultSet, context, expr, state);
                 }
@@ -713,7 +763,9 @@ class QueryField extends QueryNode {
                 else if (expr.function === 'count') {
                     agg = this.generateCountFragment(resultSet, context, expr, state);
                 }
-                else if (['count_distinct', 'min', 'max'].includes(expr.function)) {
+                else if (expr.function === 'min' ||
+                    expr.function === 'max' ||
+                    expr.function === 'distinct') {
                     agg = this.generateSymmetricFragment(resultSet, context, expr, state);
                 }
                 else {
@@ -724,68 +776,92 @@ class QueryField extends QueryNode {
                     if (state.totalGroupSet !== -1) {
                         groupSet = state.totalGroupSet;
                     }
-                    s += this.caseGroup([groupSet], agg);
-                }
-                else {
-                    s += agg;
-                }
-            }
-            else if ((0, malloy_types_1.isApplyFragment)(expr)) {
-                const applyVal = this.generateExpressionFromExpr(resultSet, context, expr.value, state);
-                s += this.generateExpressionFromExpr(resultSet, context, expr.to, state.withApply(applyVal));
-            }
-            else if ((0, malloy_types_1.isApplyValue)(expr)) {
-                if (state.applyValue) {
-                    s += state.applyValue;
-                }
-                else {
-                    throw new Error('Internal Error: Partial application value referenced but not provided');
+                    return this.caseGroup([groupSet], agg);
                 }
+                return agg;
             }
-            else if ((0, malloy_types_1.isFunctionParameterFragment)(expr)) {
+            case 'function_parameter':
                 throw new Error('Internal Error: Function parameter fragment remaining during SQL generation');
-            }
-            else if ((0, malloy_types_1.isOutputFieldFragment)(expr)) {
-                s += this.generateOutputFieldFragment(resultSet, context, expr, state);
-            }
-            else if ((0, malloy_types_1.isSQLExpressionFragment)(expr)) {
-                s += this.generateSQLExpression(resultSet, context, expr, state);
-            }
-            else if ((0, malloy_types_1.isFunctionCallFragment)(expr)) {
-                s += this.generateFunctionCallExpression(resultSet, context, expr, state);
-            }
-            else if ((0, malloy_types_1.isSpreadFragment)(expr)) {
-                s += this.generateSpread(resultSet, context, expr, state);
-            }
-            else if (expr.type === 'dialect') {
-                s += this.generateDialect(resultSet, context, expr, state);
-            }
-            else if (expr.type === 'sql-string') {
-                s += this.generateSqlString(resultSet, context, expr, state);
-            }
-            else if (expr.type === 'source-reference') {
-                s += this.generateSourceReference(resultSet, context, expr);
-            }
-            else {
-                throw new Error(`Internal Error: Unknown expression fragment ${JSON.stringify(expr, undefined, 2)}`);
-            }
+            case 'outputField':
+                return this.generateOutputFieldFragment(resultSet, context, expr, state);
+            case 'function_call':
+                return this.generateFunctionCallExpression(resultSet, context, expr, state);
+            case 'spread':
+                return this.generateSpread(resultSet, context, expr, state);
+            case 'source-reference':
+                return this.generateSourceReference(resultSet, context, expr);
+            case '+':
+            case '-':
+            case '*':
+            case '%':
+            case '/':
+            case '=':
+            case '!=':
+            case '>':
+            case '<':
+            case '>=':
+            case '<=':
+                return `${expr.kids.left.sql}${expr.node}${expr.kids.right.sql}`;
+            case 'and':
+            case 'or':
+                return `${expr.kids.left.sql} ${expr.node} ${expr.kids.right.sql}`;
+            case 'coalesce':
+                return `COALESCE(${expr.kids.left.sql},${expr.kids.right.sql})`;
+            case 'like':
+                return `${expr.kids.left.sql} LIKE ${expr.kids.right.sql}`;
+            case '!like':
+                return `${expr.kids.left.sql} NOT LIKE ${expr.kids.right.sql}`;
+            case '()':
+                return `(${expr.e.sql})`;
+            case 'not':
+                return `NOT ${expr.e.sql}`;
+            case 'unary-':
+                return `-${expr.e.sql}`;
+            case 'is-null':
+                return `${expr.e.sql} IS NULL`;
+            case 'is-not-null':
+                return `${expr.e.sql} IS NOT NULL`;
+            case 'true':
+            case 'false':
+                return expr.node;
+            case 'null':
+                return 'NULL';
+            case 'pick':
+                return this.generatePickSQL(expr);
+            case '':
+                return '';
+            case 'filterCondition':
+                // our child will be translated at the top of this function
+                if (expr.e.sql) {
+                    expr.sql = expr.e.sql;
+                    return expr.sql;
+                }
+                return '';
+            case 'functionDefaultOrderBy':
+            case 'functionOrderBy':
+                return '';
+            default:
+                throw new Error(`Internal Error: Unknown expression node '${expr.node}' ${JSON.stringify(expr, undefined, 2)}`);
         }
-        return s;
     }
     getExpr() {
         if ((0, malloy_types_1.hasExpression)(this.fieldDef)) {
             return this.fieldDef.e;
         }
-        return [
-            this.parent.dialect.sqlFieldReference(this.parent.getSQLIdentifier(), this.fieldDef.name, this.fieldDef.type, this.parent.fieldDef.structSource.type === 'nested' ||
-                this.parent.fieldDef.structSource.type === 'inline' ||
-                (this.parent.fieldDef.structSource.type === 'sql' &&
-                    this.parent.fieldDef.structSource.method === 'nested'), this.parent.fieldDef.structRelationship.type === 'nested' &&
-                this.parent.fieldDef.structRelationship.isArray),
-        ];
+        return {
+            node: 'genericSQLExpr',
+            kids: { args: [] },
+            src: [
+                this.parent.dialect.sqlFieldReference(this.parent.getSQLIdentifier(), this.fieldDef.name, this.fieldDef.type, this.parent.fieldDef.structSource.type === 'nested' ||
+                    this.parent.fieldDef.structSource.type === 'inline' ||
+                    (this.parent.fieldDef.structSource.type === 'sql' &&
+                        this.parent.fieldDef.structSource.method === 'nested'), this.parent.fieldDef.structRelationship.type === 'nested' &&
+                    this.parent.fieldDef.structRelationship.isArray),
+            ],
+        };
     }
     generateExpression(resultSet) {
-        return this.generateExpressionFromExpr(resultSet, this.parent, this.getExpr());
+        return this.exprToSQL(resultSet, this.parent, this.getExpr());
     }
 }
 function isCalculatedField(f) {
@@ -843,14 +919,13 @@ class QueryFieldStruct extends QueryAtomicField {
             structRelationship: {
                 type: 'one',
                 matrixOperation: 'left',
-                onExpression: [
-                    {
-                        type: 'field',
-                        path: [this.primaryKey],
+                onExpression: {
+                    node: '=',
+                    kids: {
+                        left: { node: 'field', path: [this.primaryKey] },
+                        right: { node: 'field', path: [foreignKeyName] },
                     },
-                    '=',
-                    { type: 'field', path: [foreignKeyName] },
-                ],
+                },
             },
         };
     }
@@ -862,8 +937,12 @@ class QueryFieldDate extends QueryAtomicField {
             return super.generateExpression(resultSet);
         }
         else {
-            const truncated = this.parent.dialect.sqlTrunc(resultSet.getQueryInfo(), { value: this.getExpr(), valueType: 'date' }, fd.timeframe);
-            return this.generateExpressionFromExpr(resultSet, this.parent, truncated);
+            const truncated = {
+                node: 'trunc',
+                e: { ...this.getExpr(), dataType: 'date' },
+                units: fd.timeframe,
+            };
+            return this.exprToSQL(resultSet, this.parent, truncated);
         }
     }
     // clone ourselves on demand as a timeframe.
@@ -973,6 +1052,12 @@ class FieldInstanceResult {
         this.resultUsesUngrouped = false;
         this.firstSegment = turtleDef.pipeline[0];
     }
+    /**
+     * Information about the query containing this result set. Invented
+     * to pass on timezone information, but maybe more things will
+     * eventually go in here.
+     * @returns QueryInfo
+     */
     getQueryInfo() {
         if (!(0, malloy_types_1.isIndexSegment)(this.firstSegment) &&
             !(0, malloy_types_1.isRawSegment)(this.firstSegment)) {
@@ -1371,7 +1456,7 @@ class JoinInstance {
                 const qf = new QueryFieldBoolean({
                     type: 'boolean',
                     name: 'ignoreme',
-                    e: filter.expression,
+                    e: filter.e,
                 }, this.queryStruct);
                 this.joinFilterConditions.push(qf);
             }
@@ -1528,31 +1613,46 @@ class QueryQuery extends QueryField {
     }
     addDependantExpr(resultStruct, context, e, joinStack) {
         var _a;
-        for (const expr of e) {
-            if ((0, malloy_types_1.isFunctionCallFragment)(expr) &&
-                (0, malloy_types_1.expressionIsAnalytic)(expr.overload.returnType.expressionType) &&
-                this.parent.dialect.cantPartitionWindowFunctionsOnExpressions) {
-                // force the use of a lateral_join_bag
-                resultStruct.root().isComplexQuery = true;
-                resultStruct.root().queryUsesPartitioning = true;
+        for (const expr of (0, utils_1.exprWalk)(e)) {
+            if (expr.node === 'function_call') {
+                if ((0, malloy_types_1.expressionIsAnalytic)(expr.overload.returnType.expressionType) &&
+                    this.parent.dialect.cantPartitionWindowFunctionsOnExpressions) {
+                    // force the use of a lateral_join_bag
+                    resultStruct.root().isComplexQuery = true;
+                    resultStruct.root().queryUsesPartitioning = true;
+                }
+                const isSymmetric = (_a = expr.overload.isSymmetric) !== null && _a !== void 0 ? _a : false;
+                const isAggregate = (0, malloy_types_1.expressionIsAggregate)(expr.overload.returnType.expressionType);
+                const isAsymmetricAggregate = isAggregate && !isSymmetric;
+                const uniqueKeyPossibleUse = isAsymmetricAggregate
+                    ? 'generic_asymmetric_aggregate'
+                    : undefined;
+                if (expr.structPath) {
+                    this.addDependantPath(resultStruct, context, expr.structPath, uniqueKeyPossibleUse, joinStack);
+                }
+                else if (isAsymmetricAggregate) {
+                    resultStruct.addStructToJoin(context, this, uniqueKeyPossibleUse, joinStack);
+                }
+                if ((0, malloy_types_1.expressionIsAnalytic)(expr.overload.returnType.expressionType)) {
+                    resultStruct.root().queryUsesPartitioning = true;
+                }
             }
-            if ((0, malloy_types_1.isUngroupFragment)(expr)) {
+            else if (expr.node === 'all' || expr.node === 'exclude') {
                 resultStruct.resultUsesUngrouped = true;
                 resultStruct.root().isComplexQuery = true;
                 resultStruct.root().queryUsesPartitioning = true;
                 if (expr.fields && expr.fields.length > 0) {
-                    const key = expr.fields.sort().join('|') + expr.type;
+                    const key = expr.fields.sort().join('|') + expr.node;
                     if (resultStruct.ungroupedSets.get(key) === undefined) {
                         resultStruct.ungroupedSets.set(key, {
-                            type: expr.type,
+                            type: expr.node,
                             fields: expr.fields,
                             groupSet: -1,
                         });
                     }
                 }
-                this.addDependantExpr(resultStruct, context, expr.e, joinStack);
             }
-            else if ((0, malloy_types_1.isFieldFragment)(expr)) {
+            if (expr.node === 'field') {
                 const field = context.getDimensionOrMeasureByName(expr.path);
                 if ((0, malloy_types_1.hasExpression)(field.fieldDef)) {
                     this.addDependantExpr(resultStruct, field.parent, field.fieldDef.e, joinStack);
@@ -1561,54 +1661,10 @@ class QueryQuery extends QueryField {
                     resultStruct
                         .root()
                         .addStructToJoin(field.parent.getJoinableParent(), this, undefined, joinStack);
-                    // this.addDependantPath(resultStruct, field.parent, expr.path, false);
-                }
-            }
-            else if ((0, malloy_types_1.isFilterFragment)(expr)) {
-                for (const filterCond of expr.filterList) {
-                    this.addDependantExpr(resultStruct, context, filterCond.expression, joinStack);
-                    this.addDependantExpr(resultStruct, context, expr.e, joinStack);
-                }
-                this.addDependantExpr(resultStruct, context, expr.e, joinStack);
-            }
-            else if ((0, malloy_types_1.isDialectFragment)(expr)) {
-                const expressions = [];
-                switch (expr.function) {
-                    case 'now':
-                        break;
-                    case 'div':
-                    case 'mod':
-                        expressions.push(expr.denominator);
-                        expressions.push(expr.numerator);
-                        break;
-                    case 'numberLiteral':
-                    case 'timeLiteral':
-                    case 'stringLiteral':
-                    case 'regexpLiteral':
-                        break;
-                    case 'timeDiff':
-                        expressions.push(expr.left.value, expr.right.value);
-                        break;
-                    case 'delta':
-                        expressions.push(expr.base.value, expr.delta);
-                        break;
-                    case 'trunc':
-                    case 'extract':
-                        expressions.push(expr.expr.value);
-                        break;
-                    case 'regexpMatch':
-                    case 'cast':
-                        expressions.push(expr.expr);
-                        break;
-                    default:
-                        throw new Error("Unknown dialect Fragment type.  Can't generate dependancies");
-                }
-                for (const e of expressions) {
-                    this.addDependantExpr(resultStruct, context, e, joinStack);
-                }
-            }
-            else if ((0, malloy_types_1.isAggregateFragment)(expr)) {
-                if ((0, malloy_types_1.isAsymmetricFragment)(expr)) {
+                }
+            }
+            else if (expr.node === 'aggregate') {
+                if ((0, malloy_types_1.isAsymmetricExpr)(expr)) {
                     if (expr.structPath) {
                         this.addDependantPath(resultStruct, context, expr.structPath, expr.function, joinStack);
                     }
@@ -1617,34 +1673,6 @@ class QueryQuery extends QueryField {
                         resultStruct.addStructToJoin(context, this, expr.function, joinStack);
                     }
                 }
-                this.addDependantExpr(resultStruct, context, expr.e, joinStack);
-            }
-            else if ((0, malloy_types_1.isFunctionCallFragment)(expr)) {
-                const isSymmetric = (_a = expr.overload.isSymmetric) !== null && _a !== void 0 ? _a : false;
-                const isAggregate = (0, malloy_types_1.expressionIsAggregate)(expr.overload.returnType.expressionType);
-                const isAsymmetricAggregate = isAggregate && !isSymmetric;
-                const uniqueKeyPossibleUse = isAsymmetricAggregate
-                    ? 'generic_asymmetric_aggregate'
-                    : undefined;
-                if (expr.structPath) {
-                    this.addDependantPath(resultStruct, context, expr.structPath, uniqueKeyPossibleUse, joinStack);
-                }
-                else if (isAsymmetricAggregate) {
-                    resultStruct.addStructToJoin(context, this, uniqueKeyPossibleUse, joinStack);
-                }
-                for (const e of expr.args) {
-                    this.addDependantExpr(resultStruct, context, e, joinStack);
-                }
-                if ((0, malloy_types_1.expressionIsAnalytic)(expr.overload.returnType.expressionType)) {
-                    resultStruct.root().queryUsesPartitioning = true;
-                }
-                if (expr.orderBy) {
-                    for (const ob of expr.orderBy) {
-                        if (ob.e) {
-                            this.addDependantExpr(resultStruct, context, ob.e, joinStack);
-                        }
-                    }
-                }
             }
         }
     }
@@ -1716,7 +1744,7 @@ class QueryQuery extends QueryField {
         // in the correct catgory.
         for (const cond of resultStruct.firstSegment.filterList || []) {
             const context = this.parent;
-            this.addDependantExpr(resultStruct, context, cond.expression, []);
+            this.addDependantExpr(resultStruct, context, cond.e, []);
         }
         for (const join of resultStruct.root().joins.values() || []) {
             for (const qf of join.joinFilterConditions || []) {
@@ -1726,9 +1754,11 @@ class QueryQuery extends QueryField {
             }
         }
     }
-    generateSQLFilters(resultStruct, which, filterList = undefined) {
+    generateSQLFilters(resultStruct, which
+    // filterList: FilterCondition[] | undefined = undefined
+    ) {
         const resultFilters = new utils_1.AndChain();
-        const list = filterList || resultStruct.firstSegment.filterList;
+        const list = resultStruct.firstSegment.filterList;
         if (list === undefined) {
             return resultFilters;
         }
@@ -1739,7 +1769,7 @@ class QueryQuery extends QueryField {
             const context = this.parent;
             if ((which === 'having' && (0, malloy_types_1.expressionIsCalculation)(cond.expressionType)) ||
                 (which === 'where' && (0, malloy_types_1.expressionIsScalar)(cond.expressionType))) {
-                const sqlClause = this.generateExpressionFromExpr(resultStruct, context, cond.expression, undefined);
+                const sqlClause = this.exprToSQL(resultStruct, context, cond.e, undefined);
                 resultFilters.add(sqlClause);
             }
         }
@@ -2935,9 +2965,7 @@ class QueryStruct extends QueryNode {
             value: param.value === null
                 ? null
                 : (0, utils_1.exprMap)(param.value, frag => {
-                    if (typeof frag === 'string')
-                        return [frag];
-                    if (frag.type === 'parameter') {
+                    if (frag.node === 'parameter') {
                         if (this.parent === undefined) {
                             throw new Error('No parent from which to retrieve parameter value');
                         }
@@ -2950,7 +2978,7 @@ class QueryStruct extends QueryNode {
                             return resolved2.value;
                         }
                     }
-                    return [frag];
+                    return frag;
                 }),
         };
     }