@malloydata/malloy 0.0.39-dev230613161129 → 0.0.39

package/dist/lang/ast/expressions/expr-cast.js

@@ -44,6 +44,7 @@ class ExprCast extends expression_def_1.ExpressionDef {
             dataType: this.castType,
             expressionType: expr.expressionType,
             value: (0, utils_1.compressExpr)((0, time_utils_1.castTo)(this.castType, expr.value, expr.dataType, this.safe)),
+            evalSpace: expr.evalSpace,
         };
     }
 }

package/dist/lang/ast/expressions/expr-coalesce.d.ts

@@ -5,7 +5,7 @@ export declare class ExprCoalesce extends ExpressionDef {
     readonly expr: ExpressionDef;
     readonly altExpr: ExpressionDef;
     elementType: string;
-    legalChildTypes: import("../types/type-desc").TypeDesc[];
+    legalChildTypes: import("../../../model").TypeDesc[];
     constructor(expr: ExpressionDef, altExpr: ExpressionDef);
     getExpression(fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/expr-coalesce.js

@@ -52,6 +52,7 @@ class ExprCoalesce extends expression_def_1.ExpressionDef {
             ...whenNull,
             expressionType: (0, model_1.maxExpressionType)(maybeNull.expressionType, whenNull.expressionType),
             value: (0, model_1.mkExpr) `COALESCE(${maybeNull.value},${whenNull.value})`,
+            evalSpace: (0, model_1.mergeEvalSpaces)(maybeNull.evalSpace, whenNull.evalSpace),
         };
     }
 }

package/dist/lang/ast/expressions/expr-count-distinct.d.ts

@@ -1,6 +1,6 @@
 import { ExprAggregateFunction } from './expr-aggregate-function';
 import { ExpressionDef } from '../types/expression-def';
 export declare class ExprCountDistinct extends ExprAggregateFunction {
-    legalChildTypes: import("../types/type-desc").TypeDesc[];
+    legalChildTypes: import("../../..").TypeDesc[];
     constructor(expr: ExpressionDef);
 }

package/dist/lang/ast/expressions/expr-count.js

@@ -50,6 +50,7 @@ class ExprCount extends expr_aggregate_function_1.ExprAggregateFunction {
             dataType: 'number',
             expressionType: 'aggregate',
             value: [ret],
+            evalSpace: 'output',
         };
     }
 }

package/dist/lang/ast/expressions/expr-filter.d.ts

@@ -6,7 +6,7 @@ export declare class ExprFilter extends ExpressionDef {
     readonly expr: ExpressionDef;
     readonly filter: Filter;
     elementType: string;
-    legalChildTypes: import("../types/type-desc").TypeDesc[];
+    legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
     constructor(expr: ExpressionDef, filter: Filter);
     getExpression(fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/expr-filter.js

@@ -38,7 +38,7 @@ class ExprFilter extends expression_def_1.ExpressionDef {
     getExpression(fs) {
         const testList = this.filter.getFilterList(fs);
         const resultExpr = this.expr.getExpression(fs);
-        if (resultExpr.expressionType === 'scalar') {
+        if (!(0, malloy_types_1.expressionIsAggregate)(resultExpr.expressionType)) {
             this.expr.log('Filtered expression requires an aggregate computation');
             return resultExpr;
         }

package/dist/lang/ast/expressions/expr-func.d.ts

@@ -1,10 +1,15 @@
+import { FieldValueType } from '../../../model/malloy_types';
+import { FieldReference } from '../query-items/field-references';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
 export declare class ExprFunc extends ExpressionDef {
     readonly name: string;
     readonly args: ExpressionDef[];
+    readonly isRaw: boolean;
+    readonly rawType: FieldValueType | undefined;
+    readonly source?: FieldReference | undefined;
     elementType: string;
-    constructor(name: string, args: ExpressionDef[]);
+    constructor(name: string, args: ExpressionDef[], isRaw: boolean, rawType: FieldValueType | undefined, source?: FieldReference | undefined);
     getExpression(fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/expr-func.js

@@ -24,40 +24,290 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprFunc = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+const struct_space_field_base_1 = require("../field-space/struct-space-field-base");
 const expression_def_1 = require("../types/expression-def");
 const utils_1 = require("./utils");
 class ExprFunc extends expression_def_1.ExpressionDef {
-    constructor(name, args) {
+    constructor(name, args, isRaw, rawType, source) {
         super({ args: args });
         this.name = name;
         this.args = args;
+        this.isRaw = isRaw;
+        this.rawType = rawType;
+        this.source = source;
         this.elementType = 'function call()';
+        this.has({ source: source });
     }
     getExpression(fs) {
-        var _a, _b, _c;
-        let expressionType = 'scalar';
-        let collectType;
-        const funcCall = [`${this.name}(`];
-        for (const fexpr of this.args) {
-            const expr = fexpr.getExpression(fs);
-            expressionType = (0, malloy_types_1.maxExpressionType)(expressionType, expr.expressionType);
-            if (collectType) {
-                funcCall.push(',');
+        var _a, _b, _c, _d;
+        const argExprsWithoutImplicit = this.args.map(arg => arg.getExpression(fs));
+        if (this.isRaw) {
+            let expressionType = 'scalar';
+            let collectType;
+            const funcCall = [`${this.name}(`];
+            for (const expr of argExprsWithoutImplicit) {
+                expressionType = (0, malloy_types_1.maxExpressionType)(expressionType, expr.expressionType);
+                if (collectType) {
+                    funcCall.push(',');
+                }
+                else {
+                    collectType = expr.dataType;
+                }
+                funcCall.push(...expr.value);
+            }
+            funcCall.push(')');
+            const dataType = (_b = (_a = this.rawType) !== null && _a !== void 0 ? _a : collectType) !== null && _b !== void 0 ? _b : 'number';
+            return {
+                dataType,
+                expressionType,
+                value: (0, utils_1.compressExpr)(funcCall),
+                evalSpace: (0, malloy_types_1.mergeEvalSpaces)(...argExprsWithoutImplicit.map(e => e.evalSpace)),
+            };
+        }
+        // TODO this makes functions case-insensitive. This is weird that this is the only place
+        // where case insensitivity is thing.
+        const func = (_c = this.modelEntry(this.name.toLowerCase())) === null || _c === void 0 ? void 0 : _c.entry;
+        if (func === undefined) {
+            this.log(`Unknown function '${this.name}'. Use '${this.name}!(...)' to call a SQL function directly.`);
+            return {
+                dataType: 'unknown',
+                expressionType: 'scalar',
+                value: [],
+                evalSpace: 'constant',
+            };
+        }
+        else if (func.type !== 'function') {
+            this.log(`Cannot call '${this.name}', which is of type ${func.type}`);
+            return {
+                dataType: 'unknown',
+                expressionType: 'scalar',
+                value: [],
+                evalSpace: 'constant',
+            };
+        }
+        // Find the 'implicit argument' for aggregate functions called like `some_join.some_field.agg(...args)`
+        // where the full arg list is `(some_field, ...args)`.
+        let implicitExpr = undefined;
+        let structPath = (_d = this.source) === null || _d === void 0 ? void 0 : _d.refString;
+        if (this.source) {
+            const sourceFoot = this.source.getField(fs).found;
+            if (sourceFoot) {
+                const footType = sourceFoot.typeDesc();
+                if ((0, malloy_types_1.isAtomicFieldType)(footType.dataType)) {
+                    implicitExpr = {
+                        dataType: footType.dataType,
+                        expressionType: footType.expressionType,
+                        value: [{ type: 'field', path: this.source.refString }],
+                        evalSpace: footType.evalSpace,
+                    };
+                    structPath = this.source.sourceString;
+                }
+                else {
+                    if (!(sourceFoot instanceof struct_space_field_base_1.StructSpaceFieldBase)) {
+                        const message = `Aggregate source cannot be a ${footType.dataType}`;
+                        this.log(message);
+                        return (0, ast_utils_1.errorFor)(message);
+                    }
+                }
             }
             else {
-                collectType = expr.dataType;
+                const message = `Reference to undefined value ${this.source.refString}`;
+                this.log(message);
+                return (0, ast_utils_1.errorFor)(message);
             }
-            funcCall.push(...expr.value);
         }
-        funcCall.push(')');
-        const dialect = fs.dialectObj();
-        const dataType = (_c = (_b = (_a = dialect === null || dialect === void 0 ? void 0 : dialect.getFunctionInfo(this.name)) === null || _a === void 0 ? void 0 : _a.returnType) !== null && _b !== void 0 ? _b : collectType) !== null && _c !== void 0 ? _c : 'number';
+        // Construct the full args list including the implicit arg.
+        const argExprs = [
+            ...(implicitExpr ? [implicitExpr] : []),
+            ...argExprsWithoutImplicit,
+        ];
+        const result = findOverload(func, argExprs);
+        if (result === undefined) {
+            this.log(`No matching overload for function ${this.name}(${argExprs
+                .map(e => e.dataType)
+                .join(', ')})`);
+            return {
+                dataType: 'unknown',
+                expressionType: 'scalar',
+                value: [],
+                evalSpace: 'constant',
+            };
+        }
+        const { overload, expressionTypeErrors, evalSpaceErrors, nullabilityErrors } = result;
+        // Report errors for expression type mismatch
+        for (const error of expressionTypeErrors) {
+            const adjustedIndex = error.argIndex - (implicitExpr ? 1 : 0);
+            const allowed = (0, malloy_types_1.expressionIsScalar)(error.maxExpressionType)
+                ? 'scalar'
+                : 'scalar or aggregate';
+            const arg = this.args[adjustedIndex];
+            arg.log(`Parameter ${error.argIndex + 1} ('${error.param.name}') of ${this.name} must be ${allowed}, but received ${error.actualExpressionType}`);
+        }
+        // Report errors for eval space mismatch
+        for (const error of evalSpaceErrors) {
+            const adjustedIndex = error.argIndex - (implicitExpr ? 1 : 0);
+            const allowed = error.maxEvalSpace === 'literal'
+                ? 'literal'
+                : error.maxEvalSpace === 'constant'
+                    ? 'literal or constant'
+                    : 'literal, constant or output';
+            const arg = this.args[adjustedIndex];
+            arg.log(`Parameter ${error.argIndex + 1} ('${error.param.name}') of ${this.name} must be ${allowed}, but received ${error.actualEvalSpace}`);
+        }
+        // Report nullability errors
+        for (const error of nullabilityErrors) {
+            const adjustedIndex = error.argIndex - (implicitExpr ? 1 : 0);
+            const arg = this.args[adjustedIndex];
+            arg.log(`Parameter ${error.argIndex + 1} ('${error.param.name}') of ${this.name} must not be a literal null`);
+        }
+        const type = overload.returnType;
+        const expressionType = (0, malloy_types_1.maxOfExpressionTypes)([
+            type.expressionType,
+            ...argExprs.map(e => e.expressionType),
+        ]);
+        if (!(0, malloy_types_1.expressionIsAggregate)(overload.returnType.expressionType) &&
+            this.source !== undefined) {
+            this.log(`Cannot call function ${this.name}(${argExprs
+                .map(e => e.dataType)
+                .join(', ')}) with source`);
+            return {
+                dataType: 'unknown',
+                expressionType,
+                value: [],
+                evalSpace: 'constant',
+            };
+        }
+        const funcCall = [
+            {
+                type: 'function_call',
+                overload,
+                args: argExprs.map(x => x.value),
+                expressionType,
+                structPath,
+            },
+        ];
+        if (type.dataType === 'any') {
+            this.log(`Invalid return type ${type.dataType} for function '${this.name}'`);
+            return {
+                dataType: 'unknown',
+                expressionType,
+                value: [],
+                evalSpace: 'constant',
+            };
+        }
+        const maxEvalSpace = (0, malloy_types_1.mergeEvalSpaces)(...argExprs.map(e => e.evalSpace));
+        // If the merged eval space of all args is constant, the result is constant.
+        // If the expression is scalar, then the eval space is that merged eval space.
+        // If the expression is aggregate, then then eval space is always 'output'.
+        // If the expression is analytic, the eval space doesn't really matter.. It's really
+        // 'super_output' but that's not useful to us, so it's just 'output'.
+        const evalSpace = maxEvalSpace === 'constant'
+            ? 'constant'
+            : (0, malloy_types_1.expressionIsScalar)(expressionType)
+                ? maxEvalSpace
+                : 'output';
         return {
-            dataType: dataType,
+            dataType: type.dataType,
             expressionType,
             value: (0, utils_1.compressExpr)(funcCall),
+            evalSpace,
         };
     }
 }
 exports.ExprFunc = ExprFunc;
+function findOverload(func, args) {
+    for (const overload of func.overloads) {
+        let paramIndex = 0;
+        let ok = true;
+        let matchedVariadic = false;
+        const expressionTypeErrors = [];
+        const evalSpaceErrors = [];
+        const nullabilityErrors = [];
+        for (let argIndex = 0; argIndex < args.length; argIndex++) {
+            const arg = args[argIndex];
+            const param = overload.params[paramIndex];
+            if (param === undefined) {
+                ok = false;
+                break;
+            }
+            const argOk = param.allowedTypes.some(paramT => {
+                // Check whether types match (allowing for nullability errors, expression type errors,
+                // eval space errors, and unknown types due to prior errors in args)
+                const dataTypeMatch = paramT.dataType === arg.dataType ||
+                    paramT.dataType === 'any' ||
+                    // TODO We should consider whether `nulls` should always be allowed. It probably
+                    // does not make sense to limit function calls to not allow nulls, since have
+                    // so little control over nullability.
+                    arg.dataType === 'null' ||
+                    // TODO I've included this because it means that errors cascade a bit less...
+                    // I think we may want to add an `error` type for nodes generated from errors,
+                    // then make `error` propagate without generating more errors.
+                    arg.dataType === 'unknown';
+                // Check expression type errors
+                if (paramT.expressionType) {
+                    const expressionTypeMatch = (0, malloy_types_1.isExpressionTypeLEQ)(arg.expressionType, paramT.expressionType);
+                    if (!expressionTypeMatch) {
+                        expressionTypeErrors.push({
+                            argIndex,
+                            maxExpressionType: paramT.expressionType,
+                            actualExpressionType: arg.expressionType,
+                            param,
+                        });
+                    }
+                }
+                // Check eval space errors
+                if (
+                // Error if literal is required but arg is not literal
+                (paramT.evalSpace === 'literal' && arg.evalSpace !== 'literal') ||
+                    // Error if constant is required but arg is input/output
+                    (paramT.evalSpace === 'constant' &&
+                        (arg.evalSpace === 'input' || arg.evalSpace === 'output')) ||
+                    // Error if output is required but arg is input
+                    (paramT.evalSpace === 'output' && arg.evalSpace === 'input')) {
+                    evalSpaceErrors.push({
+                        argIndex,
+                        param,
+                        maxEvalSpace: paramT.evalSpace,
+                        actualEvalSpace: arg.evalSpace,
+                    });
+                }
+                // Check nullability errors. For now we only require that literal arguments must be
+                // non-null, but in the future we may allow parameters to say whether they can accept literal
+                // nulls.
+                if (paramT.evalSpace === 'literal' && arg.dataType === 'null') {
+                    nullabilityErrors.push({
+                        argIndex,
+                        param,
+                    });
+                }
+                return dataTypeMatch;
+            });
+            if (!argOk) {
+                ok = false;
+                break;
+            }
+            if (param.isVariadic) {
+                if (argIndex === args.length - 1) {
+                    matchedVariadic = true;
+                }
+            }
+            else {
+                paramIndex++;
+            }
+        }
+        if (!matchedVariadic &&
+            (paramIndex !== args.length || paramIndex !== overload.params.length)) {
+            continue;
+        }
+        if (ok) {
+            return {
+                overload,
+                expressionTypeErrors,
+                evalSpaceErrors,
+                nullabilityErrors,
+            };
+        }
+    }
+}
 //# sourceMappingURL=expr-func.js.map

package/dist/lang/ast/expressions/expr-granular-time.d.ts

@@ -15,7 +15,7 @@ export declare class ExprGranularTime extends ExpressionDef {
     readonly units: TimestampUnit;
     readonly truncate: boolean;
     elementType: string;
-    legalChildTypes: import("../types/type-desc").TypeDesc[];
+    legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
     constructor(expr: ExpressionDef, units: TimestampUnit, truncate: boolean);
     granular(): boolean;
     getExpression(fs: FieldSpace): ExprValue;

package/dist/lang/ast/expressions/expr-id-reference.js

@@ -40,8 +40,18 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
     getExpression(fs) {
         const def = this.fieldReference.getField(fs);
         if (def.found) {
+            if (def.found.typeDesc().evalSpace === 'output') {
+                return {
+                    ...def.found.typeDesc(),
+                    value: [{ type: 'outputField', name: this.refString }],
+                };
+            }
             const value = [{ type: def.found.refType, path: this.refString }];
             const td = def.found.typeDesc();
+            // We think that aggregates are more 'output' like, but maybe we will reconsider that...
+            if ((0, malloy_types_1.expressionIsAggregate)(td.expressionType)) {
+                td.evalSpace = 'output';
+            }
             return { ...td, value };
         }
         this.log(def.error);
@@ -56,6 +66,8 @@ class ExprIdReference extends expression_def_1.ExpressionDef {
                 return {
                     dataType: 'boolean',
                     expressionType: lval.expressionType,
+                    // TODO not sure about the input-ness of parameters
+                    evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lval.evalSpace, 'input'),
                     value: [
                         {
                             type: 'apply',

package/dist/lang/ast/expressions/expr-logical-op.d.ts

@@ -1,5 +1,5 @@
 import { BinaryBoolean } from './binary-boolean';
 export declare class ExprLogicalOp extends BinaryBoolean<'and' | 'or'> {
     elementType: string;
-    legalChildTypes: import("../types/type-desc").TypeDesc[];
+    legalChildTypes: import("../../..").TypeDesc[];
 }

package/dist/lang/ast/expressions/expr-max.d.ts

@@ -1,9 +1,9 @@
 import { ExprValue } from '../types/expr-value';
-import { FieldValueType } from '../types/type-desc';
+import { FieldValueType } from '../../../model';
 import { ExprAggregateFunction } from './expr-aggregate-function';
 import { ExpressionDef } from '../types/expression-def';
 export declare class ExprMax extends ExprAggregateFunction {
-    legalChildTypes: import("../types/type-desc").TypeDesc[];
+    legalChildTypes: import("../../../model").TypeDesc[];
     constructor(expr: ExpressionDef);
     returns(forExpression: ExprValue): FieldValueType;
 }

package/dist/lang/ast/expressions/expr-min.d.ts

@@ -1,9 +1,9 @@
 import { ExprValue } from '../types/expr-value';
-import { FieldValueType } from '../types/type-desc';
+import { FieldValueType } from '../../../model';
 import { ExprAggregateFunction } from './expr-aggregate-function';
 import { ExpressionDef } from '../types/expression-def';
 export declare class ExprMin extends ExprAggregateFunction {
-    legalChildTypes: import("../types/type-desc").TypeDesc[];
+    legalChildTypes: import("../../../model").TypeDesc[];
     constructor(expr: ExpressionDef);
     returns(forExpression: ExprValue): FieldValueType;
 }

package/dist/lang/ast/expressions/expr-not.d.ts

@@ -4,7 +4,7 @@ import { FieldSpace } from '../types/field-space';
 import { Unary } from './unary';
 export declare class ExprNot extends Unary {
     elementType: string;
-    legalChildTypes: import("../types/type-desc").TypeDesc[];
+    legalChildTypes: import("../../..").TypeDesc[];
     constructor(expr: ExpressionDef);
     getExpression(fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/expr-now.js

@@ -33,6 +33,8 @@ class ExprNow extends expression_def_1.ExpressionDef {
         return {
             dataType: 'timestamp',
             expressionType: 'scalar',
+            // `now` is considered to be a constant, at least in the dialects we support today
+            evalSpace: 'constant',
             value: [
                 {
                     type: 'dialect',

package/dist/lang/ast/expressions/expr-null.js

@@ -34,6 +34,7 @@ class ExprNULL extends expression_def_1.ExpressionDef {
             dataType: 'null',
             value: ['NULL'],
             expressionType: 'scalar',
+            evalSpace: 'literal',
         };
     }
 }

package/dist/lang/ast/expressions/expr-number.js

@@ -35,7 +35,11 @@ class ExprNumber extends expression_def_1.ExpressionDef {
         return this.constantExpression();
     }
     constantExpression() {
-        return { ...fragtype_utils_1.FT.numberT, value: [this.n] };
+        return {
+            ...fragtype_utils_1.FT.numberT,
+            evalSpace: 'literal',
+            value: [{ type: 'dialect', function: 'numberLiteral', literal: this.n }],
+        };
     }
 }
 exports.ExprNumber = ExprNumber;

package/dist/lang/ast/expressions/expr-regex.js

@@ -34,7 +34,10 @@ class ExprRegEx extends expression_def_1.ExpressionDef {
         return {
             dataType: 'regular expression',
             expressionType: 'scalar',
-            value: [`r'${this.regex}'`],
+            value: [
+                { type: 'dialect', function: 'regexpLiteral', literal: this.regex },
+            ],
+            evalSpace: 'literal',
         };
     }
 }

package/dist/lang/ast/expressions/expr-string.js

@@ -43,6 +43,7 @@ class ExprString extends expression_def_1.ExpressionDef {
                     literal: this.value,
                 },
             ],
+            evalSpace: 'literal',
         };
     }
 }

package/dist/lang/ast/expressions/expr-time-extract.js

@@ -96,6 +96,7 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                 return {
                     dataType: 'number',
                     expressionType: (0, malloy_types_1.maxExpressionType)(first.expressionType, last.expressionType),
+                    evalSpace: (0, malloy_types_1.mergeEvalSpaces)(first.evalSpace, last.evalSpace),
                     value: [
                         {
                             type: 'dialect',
@@ -113,6 +114,7 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                     return {
                         dataType: 'number',
                         expressionType: argV.expressionType,
+                        evalSpace: argV.evalSpace,
                         value: [
                             {
                                 type: 'dialect',

package/dist/lang/ast/expressions/expr-time.js

@@ -35,6 +35,7 @@ class ExprTime extends expression_def_1.ExpressionDef {
             dataType: timeType,
             expressionType,
             value: typeof value === 'string' ? [value] : value,
+            evalSpace: 'constant',
         };
     }
     getExpression(_fs) {

package/dist/lang/ast/expressions/expr-ungroup.d.ts

@@ -1,12 +1,12 @@
+import { FieldValueType } from '../../../model/malloy_types';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldName, FieldSpace } from '../types/field-space';
-import { FieldValueType } from '../types/type-desc';
 export declare class ExprUngroup extends ExpressionDef {
     readonly control: 'all' | 'exclude';
     readonly expr: ExpressionDef;
     readonly fields: FieldName[];
-    legalChildTypes: import("../types/type-desc").TypeDesc[];
+    legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
     elementType: string;
     constructor(control: 'all' | 'exclude', expr: ExpressionDef, fields: FieldName[]);
     returns(_forExpression: ExprValue): FieldValueType;

package/dist/lang/ast/expressions/expr-ungroup.js

@@ -27,7 +27,6 @@ const malloy_types_1 = require("../../../model/malloy_types");
 const ast_utils_1 = require("../ast-utils");
 const query_spaces_1 = require("../field-space/query-spaces");
 const fragtype_utils_1 = require("../fragtype-utils");
-const field_declaration_1 = require("../query-items/field-declaration");
 const expression_def_1 = require("../types/expression-def");
 class ExprUngroup extends expression_def_1.ExpressionDef {
     constructor(control, expr, fields) {
@@ -47,21 +46,26 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
             this.expr.log(`${this.control}() expression must be an aggregate`);
             return (0, ast_utils_1.errorFor)('ungrouped scalar');
         }
+        if ((0, malloy_types_1.expressionIsUngroupedAggregate)(exprVal.expressionType)) {
+            this.expr.log(`${this.control}() expression must not already be ungrouped`);
+            return (0, ast_utils_1.errorFor)('doubly-ungrouped aggregate');
+        }
         const ungroup = {
             type: this.control,
             e: exprVal.value,
         };
         if (this.typeCheck(this.expr, { ...exprVal, expressionType: 'scalar' })) {
             if (this.fields.length > 0) {
-                let qs = fs;
-                if (fs instanceof field_declaration_1.DefSpace) {
-                    qs = fs.realFS;
+                if (!fs.isQueryFieldSpace()) {
+                    this.log(`${this.control}() must be in a query -- weird internal error`);
+                    return (0, ast_utils_1.errorFor)('ungroup query check');
                 }
-                if (!(qs instanceof query_spaces_1.QueryInputSpace)) {
+                const output = fs.outputSpace();
+                if (!(output instanceof query_spaces_1.QuerySpace)) {
+                    // TODO maybe make OutputSpace return an interface which has checkUngroup
                     this.log(`${this.control}() must be in a query -- weird internal error`);
                     return (0, ast_utils_1.errorFor)('ungroup query check');
                 }
-                const output = qs.result;
                 const dstFields = [];
                 const isExclude = this.control === 'exclude';
                 for (const mustBeInOutput of this.fields) {
@@ -70,12 +74,16 @@ class ExprUngroup extends expression_def_1.ExpressionDef {
                     });
                     dstFields.push(mustBeInOutput.refString);
                 }
+                // TODO maybe now we can just look up the fields in the output space now and ensure
+                // they're all there, rather than waiting until the query is finished to do it?
+                // See `order_by` for an example of how this could work.
                 ungroup.fields = dstFields;
             }
             return {
                 dataType: this.returns(exprVal),
-                expressionType: 'analytic',
+                expressionType: 'ungrouped_aggregate',
                 value: [ungroup],
+                evalSpace: 'output',
             };
         }
         this.log(`${this.control}() incompatible type`);

package/dist/lang/ast/expressions/for-range.d.ts

@@ -7,7 +7,7 @@ export declare class ForRange extends ExpressionDef {
     readonly duration: ExpressionDef;
     readonly timeframe: Timeframe;
     elementType: string;
-    legalChildTypes: import("../types/type-desc").TypeDesc[];
+    legalChildTypes: import("../../..").TypeDesc[];
     constructor(from: ExpressionDef, duration: ExpressionDef, timeframe: Timeframe);
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): undefined;