@malloydata/malloy 0.0.16-dev230104154319 → 0.0.16

package/dist/dialect/dialect.d.ts

@@ -28,6 +28,7 @@ export declare abstract class Dialect {
     abstract supportUnnestArrayAgg: boolean;
     abstract supportsCTEinCoorelatedSubQueries: boolean;
     abstract dontUnionIndex: boolean;
+    abstract supportsQualify: boolean;
     abstract quoteTablePath(tablePath: string): string;
     abstract sqlGroupSetTable(groupSetCount: number): string;
     abstract sqlAnyValue(groupSet: number, fieldName: string): string;

package/dist/dialect/duckdb.d.ts

@@ -14,6 +14,7 @@ export declare class DuckDBDialect extends Dialect {
     supportUnnestArrayAgg: boolean;
     supportsCTEinCoorelatedSubQueries: boolean;
     dontUnionIndex: boolean;
+    supportsQualify: boolean;
     functionInfo: Record<string, FunctionInfo>;
     get udfPrefix(): string;
     quoteTablePath(tableName: string): string;

package/dist/dialect/duckdb.js

@@ -124,6 +124,7 @@ class DuckDBDialect extends dialect_1.Dialect {
         this.supportUnnestArrayAgg = true;
         this.supportsCTEinCoorelatedSubQueries = true;
         this.dontUnionIndex = false;
+        this.supportsQualify = true;
         this.functionInfo = {
             concat: { returnType: "string" },
         };

package/dist/dialect/postgres.d.ts

@@ -15,6 +15,7 @@ export declare class PostgresDialect extends Dialect {
     supportUnnestArrayAgg: boolean;
     supportsCTEinCoorelatedSubQueries: boolean;
     dontUnionIndex: boolean;
+    supportsQualify: boolean;
     functionInfo: Record<string, FunctionInfo>;
     quoteTablePath(tablePath: string): string;
     sqlGroupSetTable(groupSetCount: number): string;

package/dist/dialect/postgres.js

@@ -53,6 +53,7 @@ class PostgresDialect extends dialect_1.Dialect {
         this.supportUnnestArrayAgg = true;
         this.supportsCTEinCoorelatedSubQueries = true;
         this.dontUnionIndex = false;
+        this.supportsQualify = false;
         this.functionInfo = {
             concat: { returnType: "string" },
         };

package/dist/dialect/standardsql.d.ts

@@ -15,6 +15,7 @@ export declare class StandardSQLDialect extends Dialect {
     supportUnnestArrayAgg: boolean;
     supportsCTEinCoorelatedSubQueries: boolean;
     dontUnionIndex: boolean;
+    supportsQualify: boolean;
     functionInfo: Record<string, FunctionInfo>;
     quoteTablePath(tablePath: string): string;
     sqlGroupSetTable(groupSetCount: number): string;

package/dist/dialect/standardsql.js

@@ -47,8 +47,12 @@ class StandardSQLDialect extends dialect_1.Dialect {
         this.supportUnnestArrayAgg = false;
         this.supportsCTEinCoorelatedSubQueries = false;
         this.dontUnionIndex = true; // bigquery can't use a sample table more than once in a query.
+        this.supportsQualify = true;
+        // I think we want an optional list of parameters types that we force a cast to.
         this.functionInfo = {
-            timestamp_seconds: { returnType: "timestamp" },
+            timestamp_seconds: {
+                returnType: "timestamp",
+            },
             concat: { returnType: "string" },
         };
         this.keywords = `

package/dist/lang/ast/apply-expr.js

@@ -57,7 +57,7 @@ function applyBinary(fs, left, op, right) {
             };
             return {
                 dataType: "number",
-                aggregate: num.aggregate || denom.aggregate,
+                expressionType: (0, malloy_types_1.maxExpressionType)(num.expressionType, denom.expressionType),
                 value: [div],
             };
         }
@@ -178,29 +178,29 @@ function equality(fs, left, op, right) {
     }
     return {
         dataType: "boolean",
-        aggregate: lhs.aggregate || rhs.aggregate,
+        expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType),
         value,
     };
 }
 function compare(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
-    const anyAggregate = lhs.aggregate || rhs.aggregate;
+    const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
     const value = timeCompare(lhs, op, rhs) || (0, index_1.compose)(lhs.value, op, rhs.value);
     return {
         dataType: "boolean",
-        aggregate: anyAggregate,
+        expressionType,
         value: value,
     };
 }
 function numeric(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
-    const anyAggregate = lhs.aggregate || rhs.aggregate;
+    const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
     if (allAre("number", lhs, rhs)) {
         return {
             dataType: "number",
-            aggregate: anyAggregate,
+            expressionType,
             value: (0, index_1.compose)(lhs.value, op, rhs.value),
         };
     }

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

@@ -1,4 +1,4 @@
-import { By, AtomicFieldType, FieldTypeDef, Fragment, TimeFieldType } from "../../model/malloy_types";
+import { By, AtomicFieldType, FieldTypeDef, Fragment, TimeFieldType, ExpressionType } from "../../model/malloy_types";
 import { FieldSpace } from "../field-space";
 import { Filter, MalloyElement, ExprValue, FieldValueType, FragType } from "./index";
 import { FieldName, FieldReference } from "./ast-main";
@@ -92,7 +92,7 @@ export declare class ExprRegEx extends ExpressionDef {
 export declare class ExprTime extends ExpressionDef {
     elementType: string;
     readonly translationValue: ExprValue;
-    constructor(timeType: TimeFieldType, value: Fragment[] | string, aggregate?: boolean);
+    constructor(timeType: TimeFieldType, value: Fragment[] | string, expressionType?: ExpressionType);
     getExpression(_fs: FieldSpace): ExprValue;
     static fromValue(timeType: TimeFieldType, expr: ExprValue): ExprTime;
 }
@@ -123,7 +123,11 @@ export declare abstract class BinaryBoolean<opType extends string> extends Expre
 }
 export declare class ExprLogicalOp extends BinaryBoolean<"and" | "or"> {
     elementType: string;
-    legalChildTypes: FragType[];
+    legalChildTypes: (FragType | {
+        aggregate: boolean;
+        dataType: FieldValueType;
+        expressionType: ExpressionType;
+    })[];
 }
 export declare class ExprIdReference extends ExpressionDef {
     readonly fieldReference: FieldReference;

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

@@ -87,7 +87,7 @@ class DollarReference extends ExpressionDef {
         return {
             dataType: this.refType,
             value: [{ type: "applyVal" }],
-            aggregate: false,
+            expressionType: "scalar",
         };
     }
 }
@@ -188,8 +188,8 @@ class FieldDeclaration extends index_1.MalloyElement {
             if (compressValue.length > 0) {
                 template.e = compressValue;
             }
-            if (exprValue.aggregate) {
-                template.aggregate = true;
+            if (exprValue.expressionType) {
+                template.expressionType = exprValue.expressionType;
             }
             if (this.exprSrc) {
                 template.code = this.exprSrc;
@@ -265,20 +265,20 @@ class ExprRegEx extends ExpressionDef {
     getExpression() {
         return {
             dataType: "regular expression",
-            aggregate: false,
+            expressionType: "scalar",
             value: [`r'${this.regex}'`],
         };
     }
 }
 exports.ExprRegEx = ExprRegEx;
 class ExprTime extends ExpressionDef {
-    constructor(timeType, value, aggregate = false) {
+    constructor(timeType, value, expressionType = "scalar") {
         super();
         this.elementType = "timestampOrDate";
         this.elementType = timeType;
         this.translationValue = {
             dataType: timeType,
-            aggregate: aggregate,
+            expressionType,
             value: typeof value === "string" ? [value] : value,
         };
     }
@@ -300,7 +300,7 @@ class ExprTime extends ExpressionDef {
             }
             value = (0, index_1.compressExpr)([toTs]);
         }
-        return new ExprTime(timeType, value, expr.aggregate);
+        return new ExprTime(timeType, value, expr.expressionType);
     }
 }
 exports.ExprTime = ExprTime;
@@ -355,7 +355,7 @@ class BinaryBoolean extends ExpressionDef {
         if (this.typeCheck(this.left, left) && this.typeCheck(this.right, right)) {
             return {
                 dataType: "boolean",
-                aggregate: left.aggregate || right.aggregate,
+                expressionType: (0, malloy_types_1.maxExpressionType)(left.expressionType, right.expressionType),
                 value: (0, index_1.compose)(left.value, this.op, right.value),
             };
         }
@@ -387,9 +387,9 @@ class ExprIdReference extends ExpressionDef {
             // TODO if type is a query or a struct this should fail nicely
             const typeMixin = def.found.type();
             const dataType = typeMixin.type;
-            const aggregate = !!typeMixin.aggregate;
+            const expressionType = typeMixin.expressionType || "scalar";
             const value = [{ type: def.found.refType, path: this.refString }];
-            return { dataType, aggregate, value };
+            return { dataType, expressionType, value };
         }
         this.log(def.error);
         return (0, index_1.errorFor)(def.error);
@@ -402,7 +402,7 @@ class ExprIdReference extends ExpressionDef {
                 const lval = expr.getExpression(fs);
                 return {
                     dataType: "boolean",
-                    aggregate: lval.aggregate,
+                    expressionType: lval.expressionType,
                     value: [
                         {
                             type: "apply",
@@ -426,7 +426,7 @@ class ExprNULL extends ExpressionDef {
         return {
             dataType: "null",
             value: ["NULL"],
-            aggregate: false,
+            expressionType: "scalar",
         };
     }
 }
@@ -504,7 +504,7 @@ class ExprAlternationTree extends BinaryBoolean {
         const choice2 = this.right.apply(fs, applyOp, expr);
         return {
             dataType: "boolean",
-            aggregate: choice1.aggregate || choice2.aggregate,
+            expressionType: (0, malloy_types_1.maxExpressionType)(choice1.expressionType, choice2.expressionType),
             value: (0, index_1.compose)(choice1.value, this.op === "&" ? "and" : "or", choice2.value),
         };
     }
@@ -542,7 +542,7 @@ class ExprAggregateFunction extends ExpressionDef {
                 if ((0, malloy_types_1.isAtomicFieldType)(footType.type)) {
                     exprVal = {
                         dataType: footType.type,
-                        aggregate: !!footType.aggregate,
+                        expressionType: footType.expressionType || "scalar",
                         value: [{ type: "field", path: this.source.refString }],
                     };
                     structPath = this.source.sourceString;
@@ -563,7 +563,10 @@ class ExprAggregateFunction extends ExpressionDef {
             this.log("Missing expression for aggregate function");
             return (0, index_1.errorFor)("agggregate without expression");
         }
-        if (this.typeCheck(this.expr || this, { ...exprVal, aggregate: false })) {
+        if (this.typeCheck(this.expr || this, {
+            ...exprVal,
+            expressionType: "scalar",
+        })) {
             const f = {
                 type: "aggregate",
                 function: this.func,
@@ -574,7 +577,7 @@ class ExprAggregateFunction extends ExpressionDef {
             }
             return {
                 dataType: this.returns(exprVal),
-                aggregate: true,
+                expressionType: "aggregate",
                 value: [f],
             };
         }
@@ -653,7 +656,7 @@ class ExprCount extends ExprAggregateFunction {
         }
         return {
             dataType: "number",
-            aggregate: true,
+            expressionType: "aggregate",
             value: [ret],
         };
     }
@@ -687,12 +690,12 @@ class ExprUngroup extends ExpressionDef {
     }
     getExpression(fs) {
         const exprVal = this.expr.getExpression(fs);
-        if (!exprVal.aggregate) {
+        if (!(0, malloy_types_1.expressionIsAggregate)(exprVal.expressionType)) {
             this.expr.log(`${this.control}() expression must be an aggregate`);
             return (0, index_1.errorFor)("ungrouped scalar");
         }
         const ungroup = { type: this.control, e: exprVal.value };
-        if (this.typeCheck(this.expr, { ...exprVal, aggregate: false })) {
+        if (this.typeCheck(this.expr, { ...exprVal, expressionType: "scalar" })) {
             if (this.fields.length > 0) {
                 let qs = fs;
                 if (fs instanceof field_space_1.DefSpace) {
@@ -715,7 +718,7 @@ class ExprUngroup extends ExpressionDef {
             }
             return {
                 dataType: this.returns(exprVal),
-                aggregate: true,
+                expressionType: "analytic",
                 value: [ungroup],
             };
         }
@@ -746,12 +749,12 @@ class ExprCase extends ExpressionDef {
     }
     getExpression(fs) {
         let retType;
-        let aggregate = false;
+        let expressionType = "scalar";
         const caseExpr = ["CASE "];
         for (const clause of this.when) {
             const whenExpr = clause.whenThis.getExpression(fs);
             const thenExpr = clause.thenThis.getExpression(fs);
-            aggregate || (aggregate = whenExpr.aggregate || thenExpr.aggregate);
+            expressionType = (0, malloy_types_1.maxExpressionType)(expressionType, (0, malloy_types_1.maxExpressionType)(whenExpr.expressionType, thenExpr.expressionType));
             if (thenExpr.dataType !== "null") {
                 if (retType && !index_1.FT.typeEq(retType, thenExpr)) {
                     this.log(`Mismatched THEN clause types, ${index_1.FT.inspect(retType, thenExpr)}`);
@@ -765,7 +768,7 @@ class ExprCase extends ExpressionDef {
         }
         if (this.elseClause) {
             const elseExpr = this.elseClause.getExpression(fs);
-            aggregate || (aggregate = elseExpr.aggregate);
+            expressionType = (0, malloy_types_1.maxExpressionType)(expressionType, elseExpr.expressionType);
             caseExpr.push(" ELSE ", ...elseExpr.value);
             if (elseExpr.dataType !== "null") {
                 if (retType && !index_1.FT.typeEq(retType, elseExpr)) {
@@ -784,7 +787,7 @@ class ExprCase extends ExpressionDef {
         caseExpr.push(" END");
         return {
             dataType: retType.dataType,
-            aggregate: aggregate,
+            expressionType,
             value: caseExpr,
         };
     }
@@ -802,17 +805,17 @@ class ExprFilter extends ExpressionDef {
         const testList = this.filter.getFilterList(fs);
         const resultExpr = this.expr.getExpression(fs);
         for (const cond of testList) {
-            if (cond.aggregate) {
-                this.filter.log("Cannot filter a field with an aggregate computation");
+            if ((0, malloy_types_1.expressionIsCalculation)(cond.expressionType)) {
+                this.filter.log("Cannot filter a field with an aggregate or analytical computation");
                 return (0, index_1.errorFor)("no filter on aggregate");
             }
         }
-        if (!resultExpr.aggregate) {
+        if (resultExpr.expressionType === "scalar") {
             // TODO could log a warning, but I have a problem with the
             // idea of warnings, so for now ...
             return resultExpr;
         }
-        if (this.typeCheck(this.expr, { ...resultExpr, aggregate: false })) {
+        if (this.typeCheck(this.expr, { ...resultExpr, expressionType: "scalar" })) {
             return {
                 ...resultExpr,
                 value: [
@@ -845,7 +848,7 @@ class ExprCast extends ExpressionDef {
         const expr = this.expr.getExpression(fs);
         return {
             dataType: this.castType,
-            aggregate: expr.aggregate,
+            expressionType: expr.expressionType,
             value: (0, index_1.compressExpr)((0, time_utils_1.castTo)(this.castType, expr.value, this.safe)),
         };
     }
@@ -863,7 +866,7 @@ class TopBy extends index_1.MalloyElement {
     getBy(fs) {
         if (this.by instanceof ExpressionDef) {
             const byExpr = this.by.getExpression(fs);
-            if (!byExpr.aggregate) {
+            if (!(0, malloy_types_1.expressionIsAggregate)(byExpr.expressionType)) {
                 this.log("top by expression must be an aggregate");
             }
             return { by: "expression", e: (0, index_1.compressExpr)(byExpr.value) };
@@ -890,7 +893,7 @@ class Range extends ExpressionDef {
                 const toValue = this.last.apply(fs, op3, expr);
                 return {
                     dataType: "boolean",
-                    aggregate: fromValue.aggregate || toValue.aggregate,
+                    expressionType: (0, malloy_types_1.maxExpressionType)(fromValue.expressionType, toValue.expressionType),
                     value: (0, index_1.compose)(fromValue.value, op2, toValue.value),
                 };
             }
@@ -961,13 +964,13 @@ class Pick extends ExpressionDef {
     apply(fs, op, expr) {
         const caseValue = ["CASE"];
         let returnType;
-        let anyAggregate = false;
+        let anyExpressionType = "scalar";
         for (const choice of this.choices) {
             const whenExpr = choice.when.apply(fs, "=", expr);
             const thenExpr = choice.pick
                 ? choice.pick.getExpression(fs)
                 : expr.getExpression(fs);
-            anyAggregate || (anyAggregate = whenExpr.aggregate || thenExpr.aggregate);
+            anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(whenExpr.expressionType, thenExpr.expressionType));
             if (returnType) {
                 if (!index_1.FT.typeEq(returnType, thenExpr, true)) {
                     const whenType = index_1.FT.inspect(thenExpr);
@@ -990,7 +993,7 @@ class Pick extends ExpressionDef {
         }
         return {
             dataType: returnType.dataType,
-            aggregate: anyAggregate || elseVal.aggregate,
+            expressionType: (0, malloy_types_1.maxExpressionType)(anyExpressionType, elseVal.expressionType),
             value: (0, index_1.compressExpr)([...caseValue, " ELSE ", ...elseVal.value, " END"]),
         };
     }
@@ -1017,7 +1020,7 @@ class Pick extends ExpressionDef {
         }
         const returnType = choiceValues[0].pick;
         const caseValue = ["CASE"];
-        let anyAggregate = returnType.aggregate;
+        let anyExpressionType = returnType.expressionType;
         for (const aChoice of choiceValues) {
             if (!index_1.FT.typeEq(aChoice.when, index_1.FT.boolT)) {
                 this.log(`when expression must be boolean, not '${index_1.FT.inspect(aChoice.when)}`);
@@ -1028,11 +1031,11 @@ class Pick extends ExpressionDef {
                 this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
                 return (0, index_1.errorFor)("pick value type");
             }
-            anyAggregate || (anyAggregate = aChoice.pick.aggregate || aChoice.when.aggregate);
+            anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(aChoice.pick.expressionType, aChoice.when.expressionType));
             caseValue.push(" WHEN ", ...aChoice.when.value, " THEN ", ...aChoice.pick.value);
         }
         const defVal = this.elsePick.getExpression(fs);
-        anyAggregate || (anyAggregate = defVal.aggregate);
+        anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, defVal.expressionType);
         if (!index_1.FT.typeEq(returnType, defVal, true)) {
             this.elsePick.log(`else type '${index_1.FT.inspect(defVal)}', expected '${returnType.dataType}'`);
             return (0, index_1.errorFor)("pick value type mismatch");
@@ -1040,7 +1043,7 @@ class Pick extends ExpressionDef {
         caseValue.push(" ELSE ", ...defVal.value, " END");
         return {
             dataType: returnType.dataType,
-            aggregate: !!anyAggregate,
+            expressionType: anyExpressionType,
             value: (0, index_1.compressExpr)(caseValue),
         };
     }

package/dist/lang/ast/ast-main.js

@@ -546,7 +546,7 @@ class RefinedExplore extends Mallobj {
         for (const filter of filters) {
             for (const el of filter.list) {
                 const fc = el.filterExpression(fs);
-                if (fc.aggregate) {
+                if (model.expressionIsCalculation(fc.expressionType)) {
                     el.log("Can't use aggregate computations in top level filters");
                 }
                 else {
@@ -925,15 +925,14 @@ class FilterElement extends MalloyElement {
             return {
                 code: this.exprSrc,
                 expression: ["_FILTER_MUST_RETURN_BOOLEAN_"],
+                expressionType: "scalar",
             };
         }
         const exprCond = {
             code: this.exprSrc,
             expression: (0, index_1.compressExpr)(exprVal.value),
+            expressionType: exprVal.expressionType,
         };
-        if (exprVal.aggregate) {
-            exprCond.aggregate = true;
-        }
         return exprCond;
     }
 }
@@ -954,14 +953,14 @@ class Filter extends ListOf {
             // here allows better reflection of errors back to user.
             if (this.havingClause !== undefined) {
                 if (this.havingClause) {
-                    if (!fExpr.aggregate) {
-                        oneElement.log("Aggregate expression expected in HAVING filter");
+                    if (model.expressionIsCalculation(fExpr.expressionType)) {
+                        oneElement.log("Aggregate or Analytical expression expected in HAVING filter");
                         continue;
                     }
                 }
                 else {
-                    if (fExpr.aggregate) {
-                        oneElement.log("Aggregate expression not allowed in WHERE");
+                    if (fExpr.expressionType !== "scalar") {
+                        oneElement.log("Aggregate or Analytical expressions not allowed in WHERE");
                         continue;
                     }
                 }
@@ -1921,7 +1920,7 @@ class Top extends MalloyElement {
             }
             else {
                 const byExpr = this.by.getExpression(fs);
-                if (!byExpr.aggregate) {
+                if (model.expressionIsAggregate(byExpr.expressionType)) {
                     this.log("top by expression must be an aggregate");
                 }
                 return { by: "expression", e: (0, index_1.compressExpr)(byExpr.value) };

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

@@ -98,15 +98,15 @@ class ExprGranularTime extends index_1.ExpressionDef {
     timestampRange(fs, op, expr) {
         const begin = this.getExpression(fs);
         const beginTime = index_1.ExprTime.fromValue("timestamp", begin);
-        const endTime = new index_1.ExprTime("timestamp", (0, index_1.timeOffset)("timestamp", begin.value, "+", (0, malloy_types_1.mkExpr) `1`, this.units), begin.aggregate);
+        const endTime = new index_1.ExprTime("timestamp", (0, index_1.timeOffset)("timestamp", begin.value, "+", (0, malloy_types_1.mkExpr) `1`, this.units), begin.expressionType);
         const range = new index_1.Range(beginTime, endTime);
         return range.apply(fs, op, expr);
     }
     dateRange(fs, op, expr) {
         const begin = this.getExpression(fs);
-        const beginTime = new index_1.ExprTime("date", begin.value, begin.aggregate);
+        const beginTime = new index_1.ExprTime("date", begin.value, begin.expressionType);
         const endAt = (0, index_1.timeOffset)("date", begin.value, "+", ["1"], this.units);
-        const end = new index_1.ExprTime("date", endAt, begin.aggregate);
+        const end = new index_1.ExprTime("date", endAt, begin.expressionType);
         const range = new index_1.Range(beginTime, end);
         return range.apply(fs, op, expr);
     }
@@ -206,7 +206,7 @@ class GranularLiteral extends index_1.ExpressionDef {
         const dataType = this.timeType || "date";
         const value = {
             dataType,
-            aggregate: false,
+            expressionType: "scalar",
             value: (0, index_1.timeLiteral)(this.moment, dataType, "UTC"),
         };
         // Literals with date resolution can be used as timestamps or dates,
@@ -236,7 +236,7 @@ class ExprNow extends index_1.ExpressionDef {
     getExpression(_fs) {
         return {
             dataType: "timestamp",
-            aggregate: false,
+            expressionType: "scalar",
             value: [
                 {
                     type: "dialect",
@@ -275,13 +275,13 @@ class ExprDuration extends index_1.ExpressionDef {
                 const result = (0, index_1.timeOffset)("timestamp", lhs.value, op, num.value, this.timeframe);
                 return (0, index_1.timeResult)({
                     dataType: "timestamp",
-                    aggregate: lhs.aggregate || num.aggregate,
+                    expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
                     value: result,
                 }, resultGranularity);
             }
             return (0, index_1.timeResult)({
                 dataType: "date",
-                aggregate: lhs.aggregate || num.aggregate,
+                expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
                 value: (0, index_1.timeOffset)("date", lhs.value, op, num.value, this.timeframe),
             }, resultGranularity);
         }
@@ -290,7 +290,7 @@ class ExprDuration extends index_1.ExpressionDef {
     getExpression(_fs) {
         return {
             dataType: "duration",
-            aggregate: false,
+            expressionType: "scalar",
             value: ["__ERROR_DURATION_IS_NOT_A_VALUE__"],
         };
     }
@@ -408,10 +408,10 @@ class ForRange extends index_1.ExpressionDef {
                 // ... not a literal, need a cast
                 from = (0, index_1.castDateToTimestamp)(from);
             }
-            rangeStart = new index_1.ExprTime("timestamp", from, startV.aggregate);
+            rangeStart = new index_1.ExprTime("timestamp", from, startV.expressionType);
         }
         const to = (0, index_1.timeOffset)("timestamp", from, "+", nV.value, units);
-        const rangeEnd = new index_1.ExprTime("timestamp", to, startV.aggregate);
+        const rangeEnd = new index_1.ExprTime("timestamp", to, startV.expressionType);
         return new index_1.Range(rangeStart, rangeEnd).apply(fs, op, applyTo);
     }
     requestExpression(_fs) {
@@ -464,7 +464,7 @@ class ExprTimeExtract extends index_1.ExpressionDef {
                 }
                 return {
                     dataType: "number",
-                    aggregate: first.aggregate || last.aggregate,
+                    expressionType: (0, malloy_types_1.maxExpressionType)(first.expressionType, last.expressionType),
                     value: [
                         {
                             type: "dialect",
@@ -481,7 +481,7 @@ class ExprTimeExtract extends index_1.ExpressionDef {
                 if ((0, malloy_types_1.isTimeFieldType)(argV.dataType)) {
                     return {
                         dataType: "number",
-                        aggregate: argV.aggregate,
+                        expressionType: argV.expressionType,
                         value: [
                             {
                                 type: "dialect",
@@ -519,14 +519,12 @@ class ExprFunc extends index_1.ExpressionDef {
     }
     getExpression(fs) {
         var _a, _b, _c;
-        let anyAggregate = false;
+        let expressionType = "scalar";
         let collectType;
         const funcCall = [`${this.name}(`];
         for (const fexpr of this.args) {
             const expr = fexpr.getExpression(fs);
-            if (expr.aggregate) {
-                anyAggregate = true;
-            }
+            expressionType = (0, malloy_types_1.maxExpressionType)(expressionType, expr.expressionType);
             if (collectType) {
                 funcCall.push(",");
             }
@@ -540,7 +538,7 @@ class ExprFunc extends index_1.ExpressionDef {
         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";
         return {
             dataType: dataType,
-            aggregate: anyAggregate,
+            expressionType,
             value: (0, index_1.compressExpr)(funcCall),
         };
     }

package/dist/lang/ast/ast-types.d.ts

@@ -1,11 +1,11 @@
-import { AtomicFieldType, Fragment, TimestampUnit, Expr, TimeFieldType } from "../../model/malloy_types";
+import { AtomicFieldType, Fragment, TimestampUnit, Expr, TimeFieldType, ExpressionType } from "../../model/malloy_types";
 export declare type ExpressionValueType = AtomicFieldType | "null" | "unknown" | "duration" | "regular expression";
 export declare function isExpressionValueType(fv: FieldValueType): fv is ExpressionValueType;
 export declare type StageFieldType = "turtle";
 export declare type FieldValueType = ExpressionValueType | StageFieldType | "struct";
 export interface FragType {
     dataType: FieldValueType;
-    aggregate: boolean;
+    expressionType: ExpressionType;
 }
 /**
  * Collects functions which operate on fragtype compatible objects

package/dist/lang/ast/ast-types.js

@@ -43,7 +43,7 @@ class FT {
     static eq(good, checkThis) {
         return (checkThis !== undefined &&
             good.dataType === checkThis.dataType &&
-            good.aggregate === checkThis.aggregate);
+            good.expressionType === checkThis.expressionType);
     }
     /**
      * Checks if the base types, ignoring aggregate, are equal
@@ -66,8 +66,8 @@ class FT {
         const strings = types.map((type) => {
             if (type) {
                 let inspected = type.dataType;
-                if (type.aggregate) {
-                    inspected = `aggregate ${inspected}`;
+                if (type.expressionType != "scalar") {
+                    inspected = `expressionType ${type.expressionType}`;
                 }
                 return inspected;
             }
@@ -91,7 +91,7 @@ FT.anyAtomicT = [
     FT.boolT,
 ];
 function mkFragType(dType) {
-    return { dataType: dType, aggregate: false };
+    return { dataType: dType, expressionType: "scalar" };
 }
 function isGranularResult(v) {
     if (v.dataType !== "date" && v.dataType !== "timestamp") {
@@ -111,7 +111,7 @@ exports.isGranularResult = isGranularResult;
 function errorFor(reason) {
     return {
         dataType: "unknown",
-        aggregate: false,
+        expressionType: "scalar",
         value: [`_ERROR_${reason.replace(/ /g, "_")}`],
     };
 }

package/dist/lang/field-space.js

@@ -555,7 +555,7 @@ class ProjectFieldSpace extends ResultSpace {
                 this.log("Cannot nest queries in project");
                 return false;
             }
-            if (qd.aggregate) {
+            if (model.expressionIsAggregate(qd.expressionType)) {
                 this.log("Cannot add aggregate measures to project");
                 return false;
             }

package/dist/lang/space-field.d.ts

@@ -3,7 +3,7 @@ import { FieldSpace, DynamicSpace, QuerySpace } from "./field-space";
 import { FieldValueType, FieldDeclaration, TurtleDecl, HasParameter, Join, FieldReference } from "./ast";
 interface FieldType {
     type: FieldValueType;
-    aggregate?: boolean;
+    expressionType?: model.ExpressionType;
 }
 export declare abstract class SpaceEntry {
     abstract type(): FieldType;

package/dist/lang/space-field.js

@@ -82,8 +82,8 @@ class SpaceField extends SpaceEntry {
     }
     fieldTypeFromFieldDef(def) {
         const ref = { type: def.type };
-        if (model.isFieldTypeDef(def) && def.aggregate) {
-            ref.aggregate = true;
+        if (model.isFieldTypeDef(def) && def.expressionType) {
+            ref.expressionType = def.expressionType;
         }
         return ref;
     }
@@ -256,7 +256,7 @@ class FANSPaceField extends SpaceField {
                     type: fieldType,
                     name: this.as,
                     e: [{ type: "parameter", path: this.ref.refString }],
-                    aggregate: false,
+                    expressionType: "scalar",
                 };
             }
             let fieldExpr = [{ type: "field", path: this.ref.refString }];
@@ -274,7 +274,7 @@ class FANSPaceField extends SpaceField {
                 type: fieldType,
                 name: this.as,
                 e: fieldExpr,
-                aggregate: fieldTypeInfo.aggregate,
+                expressionType: fieldTypeInfo.expressionType,
             };
         }
         return undefined;

package/dist/lang/test/parse.spec.js

@@ -832,7 +832,7 @@ describe("qops", () => {
                 const f = q.extendSource[0];
                 expect(f.type).toBe("number");
                 if (f.type == "number") {
-                    expect(f.aggregate).toBeTruthy();
+                    expect((0, model_1.expressionIsCalculation)(f.expressionType)).toBeTruthy();
                 }
             }
             else {
@@ -856,7 +856,7 @@ describe("qops", () => {
                 const f = q.extendSource[0];
                 expect(f.type).toBe("number");
                 if (f.type == "number") {
-                    expect(f.aggregate).toBeTruthy();
+                    expect((0, model_1.expressionIsCalculation)(f.expressionType)).toBeTruthy();
                 }
             }
             else {

package/dist/lang/test/test-translator.js

@@ -192,7 +192,7 @@ class TestTranslator extends parse_malloy_1.MalloyTranslator {
                             type: "number",
                             name: "acount",
                             numberType: "integer",
-                            aggregate: true,
+                            expressionType: "aggregate",
                             e: ["COUNT()"],
                             code: "count()",
                         },

package/dist/malloy.d.ts

@@ -507,7 +507,7 @@ export declare class AtomicField extends Entity {
     isQueryField(): this is QueryField;
     isExploreField(): this is ExploreField;
     isAtomicField(): this is AtomicField;
-    isAggregate(): boolean;
+    isCalculation(): boolean;
     get sourceField(): Field;
     get sourceClasses(): string[];
     sourceWasMeasure(): boolean;

package/dist/malloy.js

@@ -1005,8 +1005,9 @@ class AtomicField extends Entity {
     isAtomicField() {
         return true;
     }
-    isAggregate() {
-        return !!this.fieldTypeDef.aggregate;
+    isCalculation() {
+        //return !!this.fieldTypeDef.aggregate;
+        return (0, model_1.expressionIsCalculation)(this.fieldTypeDef.expressionType);
     }
     get sourceField() {
         // TODO

package/dist/model/malloy_query.d.ts

@@ -1,5 +1,5 @@
 import { Dialect, DialectFieldList } from "../dialect";
-import { FieldDef, FieldRef, FilterExpression, ModelDef, Query, QueryFieldDef, StructDef, StructRef, OrderBy, ResultMetadataDef, Expr, FieldFragment, AggregateFragment, CompiledQuery, FilterFragment, PipeSegment, TurtleDef, QuerySegment, Filtered, ParameterFragment, Parameter, JoinRelationship, DialectFragment, UngroupFragment, NamedQuery } from "./malloy_types";
+import { FieldDef, FieldRef, FilterExpression, ModelDef, Query, QueryFieldDef, StructDef, StructRef, OrderBy, ResultMetadataDef, Expr, FieldFragment, AggregateFragment, CompiledQuery, FilterFragment, PipeSegment, TurtleDef, QuerySegment, Filtered, ParameterFragment, Parameter, JoinRelationship, DialectFragment, UngroupFragment, NamedQuery, AnalyticFragment } from "./malloy_types";
 import { AndChain } from "./utils";
 import { ResultStructMetadataDef, SearchIndexResult } from ".";
 import { Connection } from "..";
@@ -64,13 +64,14 @@ declare class QueryField extends QueryNode {
     generateAvgFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateFragment, state: GenerateState): string;
     generateCountFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateFragment, state: GenerateState): string;
     generateDialect(resultSet: FieldInstanceResult, context: QueryStruct, expr: DialectFragment, state: GenerateState): string;
+    generateAnalyticFragment(resultStruct: FieldInstanceResult, context: QueryStruct, expr: AnalyticFragment, state: GenerateState): string;
     generateExpressionFromExpr(resultSet: FieldInstanceResult, context: QueryStruct, e: Expr, state?: GenerateState): string;
     getExpr(): Expr;
     generateExpression(resultSet: FieldInstanceResult): string;
 }
 declare class QueryAtomicField extends QueryField {
     includeInWildcard(): boolean;
-    isAggregate(): boolean;
+    isCalculated(): boolean;
     getFilterList(): FilterExpression[];
     hasExpression(): boolean;
 }
@@ -157,7 +158,7 @@ declare class FieldInstanceResultRoot extends FieldInstanceResult {
     joins: Map<string, JoinInstance>;
     havings: AndChain;
     isComplexQuery: boolean;
-    queryUsesUngrouped: boolean;
+    queryUsesPartitioning: boolean;
     computeOnlyGroups: number[];
     elimatedComputeGroups: boolean;
     constructor(turtleDef: TurtleDef);

package/dist/model/malloy_query.js

@@ -340,6 +340,62 @@ class QueryField extends QueryNode {
     generateDialect(resultSet, context, expr, state) {
         return this.generateExpressionFromExpr(resultSet, context, context.dialect.dialectExpr(expr), state);
     }
+    generateAnalyticFragment(resultStruct, context, expr, state) {
+        const fields = resultStruct.getUngroupPartitions(undefined);
+        let partitionBy = "";
+        const fieldsString = fields.map((f) => f.getPartitionSQL()).join(", ");
+        if (fieldsString.length > 0) {
+            partitionBy = `PARTITION BY ${fieldsString}`;
+        }
+        let orderBy = "";
+        // calculate the ordering.
+        const obSQL = [];
+        let orderingField;
+        const orderByDef = resultStruct.firstSegment.orderBy ||
+            resultStruct.calculateDefaultOrderBy();
+        for (const ordering of orderByDef) {
+            if (typeof ordering.field === "string") {
+                orderingField = {
+                    name: ordering.field,
+                    fif: resultStruct.getField(ordering.field),
+                };
+            }
+            else {
+                orderingField = resultStruct.getFieldByNumber(ordering.field);
+            }
+            if (resultStruct.firstSegment.type === "reduce") {
+                obSQL.push(" " +
+                    orderingField.fif.getSQL() +
+                    // this.parent.dialect.sqlMaybeQuoteIdentifier(
+                    //   `${orderingField.name}__${resultStruct.groupSet}`
+                    // ) +
+                    ` ${ordering.dir || "ASC"}`);
+            }
+            else if (resultStruct.firstSegment.type === "project") {
+                obSQL.push(` ${orderingField.fif.f.generateExpression(resultStruct)} ${ordering.dir || "ASC"}`);
+            }
+        }
+        const func = malloy_types_1.malloyFunctions[expr.function];
+        const paramSQL = [];
+        if (expr.parameters !== undefined) {
+            for (const e of expr.parameters) {
+                if (typeof e === "string") {
+                    paramSQL.push(e); // need to map to dimensional expression.
+                }
+                else if (typeof e === "number") {
+                    paramSQL.push(e.toString());
+                }
+                else {
+                    paramSQL.push(this.generateExpressionFromExpr(resultStruct, context, e, state));
+                }
+            }
+        }
+        if (obSQL.length > 0) {
+            orderBy = " " + this.parent.dialect.sqlOrderBy(obSQL);
+        }
+        const sqlName = func.sqlName || expr.function;
+        return `${sqlName}(${paramSQL.join(", ")}) OVER(${partitionBy} ${orderBy} )`;
+    }
     generateExpressionFromExpr(resultSet, context, e, state = new GenerateState()) {
         let s = "";
         for (const expr of e) {
@@ -358,6 +414,9 @@ class QueryField extends QueryNode {
             else if ((0, malloy_types_1.isUngroupFragment)(expr)) {
                 s += this.generateUngroupedFragment(resultSet, context, expr, state);
             }
+            else if ((0, malloy_types_1.isAnalyticFragment)(expr)) {
+                s += this.generateAnalyticFragment(resultSet, context, expr, state);
+            }
             else if ((0, malloy_types_1.isAggregateFragment)(expr)) {
                 let agg;
                 if (expr.function === "sum") {
@@ -423,19 +482,18 @@ class QueryField extends QueryNode {
         return this.generateExpressionFromExpr(resultSet, this.parent, this.getExpr());
     }
 }
-function isAggregateField(f) {
-    return f instanceof QueryAtomicField && f.isAggregate();
+function isCalculatedField(f) {
+    return f instanceof QueryAtomicField && f.isCalculated();
 }
 function isScalarField(f) {
-    return f instanceof QueryAtomicField && !f.isAggregate();
+    return f instanceof QueryAtomicField && !f.isCalculated();
 }
 class QueryAtomicField extends QueryField {
     includeInWildcard() {
         return true;
     }
-    isAggregate() {
-        return (this.fieldDef.aggregate !== undefined &&
-            this.fieldDef.aggregate === true);
+    isCalculated() {
+        return (0, malloy_types_1.expressionIsCalculation)(this.fieldDef.expressionType);
     }
     getFilterList() {
         return [];
@@ -754,7 +812,7 @@ class FieldInstanceResult {
                     if (["date", "timestamp"].indexOf(fi.f.fieldDef.type) > -1) {
                         return [{ dir: "desc", field: fi.fieldUsage.resultIndex }];
                     }
-                    else if (isAggregateField(fi.f)) {
+                    else if (isCalculatedField(fi.f)) {
                         return [{ dir: "desc", field: fi.fieldUsage.resultIndex }];
                     }
                 }
@@ -873,7 +931,7 @@ class FieldInstanceResultRoot extends FieldInstanceResult {
         this.joins = new Map();
         this.havings = new utils_1.AndChain();
         this.isComplexQuery = false;
-        this.queryUsesUngrouped = false;
+        this.queryUsesPartitioning = false;
         this.computeOnlyGroups = [];
         this.elimatedComputeGroups = false;
     }
@@ -1114,7 +1172,7 @@ class QueryQuery extends QueryField {
             // turtles
             // Timestamps and Dates (are just fine to leave as is).
             // measures
-            let e;
+            // let e: Expr;
             if (field instanceof QueryQuery) {
                 const newFieldDef = (0, lodash_1.cloneDeep)(field.fieldDef);
                 newFieldDef.as = f.name;
@@ -1123,18 +1181,18 @@ class QueryQuery extends QueryField {
             }
             else if (!(field instanceof QueryFieldTimestamp ||
                 field instanceof QueryFieldDate)) {
-                // its a measure
-                e = [{ type: "field", path: field.getFullOutputName() }];
-                if ("filterList" in f && f.filterList) {
-                    e = [{ type: "filterExpression", filterList: f.filterList, e: e }];
-                }
-                const newFieldDef = {
-                    type: field.fieldDef.type,
-                    name: f.as,
-                    e,
-                    aggregate: isAggregateField(field),
-                };
-                field = this.parent.makeQueryField(newFieldDef);
+                throw new Error(`No longer generate code this way. \n ${JSON.stringify(f, undefined, 2)}`);
+                // // its a measure
+                // e = [{ type: "field", path: field.getFullOutputName() }];
+                // if ("filterList" in f && f.filterList) {
+                //   e = [{ type: "filterExpression", filterList: f.filterList, e: e }];
+                // }
+                // const newFieldDef = {
+                //   type: field.fieldDef.type,
+                //   name: f.as,
+                //   e,
+                // };
+                // field = this.parent.makeQueryField(newFieldDef as FieldDef);
             }
             // or inline field FieldTypeDef
         }
@@ -1228,7 +1286,7 @@ class QueryQuery extends QueryField {
             if ((0, malloy_types_1.isUngroupFragment)(expr)) {
                 resultStruct.resultUsesUngrouped = true;
                 resultStruct.root().isComplexQuery = true;
-                resultStruct.root().queryUsesUngrouped = true;
+                resultStruct.root().queryUsesPartitioning = true;
                 if (expr.fields && expr.fields.length > 0) {
                     const key = expr.fields.sort().join("|") + expr.type;
                     if (resultStruct.ungroupedSets.get(key) === undefined) {
@@ -1304,6 +1362,9 @@ class QueryQuery extends QueryField {
                 }
                 this.addDependantExpr(resultStruct, context, expr.e, joinStack);
             }
+            else if ((0, malloy_types_1.isAnalyticFragment)(expr)) {
+                resultStruct.root().queryUsesPartitioning = true;
+            }
         }
     }
     addDependancies(resultStruct, field) {
@@ -1329,7 +1390,7 @@ class QueryQuery extends QueryField {
                     type: "result",
                 });
                 this.addDependancies(resultStruct, field);
-                if (isAggregateField(field)) {
+                if (isCalculatedField(field)) {
                     if (this.firstSegment.type === "project") {
                         throw new Error(`Aggregate Fields cannot be used in PROJECT - '${field.fieldDef.name}'`);
                     }
@@ -1387,8 +1448,8 @@ class QueryQuery extends QueryField {
         // in the correct catgory.
         for (const cond of list || []) {
             const context = this.parent;
-            if ((which === "having" && cond.aggregate) ||
-                (which === "where" && !cond.aggregate)) {
+            if ((which === "having" && (0, malloy_types_1.expressionIsCalculation)(cond.expressionType)) ||
+                (which === "where" && cond.expressionType === "scalar")) {
                 const sqlClause = this.generateExpressionFromExpr(resultStruct, context, cond.expression, undefined);
                 resultFilters.add(sqlClause);
             }
@@ -1412,7 +1473,7 @@ class QueryQuery extends QueryField {
                 const sourceField = fi.f.parent.getFullOutputName() + (fieldDef.name || fieldDef.as);
                 const sourceExpression = fieldDef.code;
                 const sourceClasses = [sourceField];
-                if (isAggregateField(fi.f)) {
+                if (isCalculatedField(fi.f)) {
                     filterList = fi.f.getFilterList();
                     return {
                         sourceField,
@@ -1762,7 +1823,7 @@ class QueryQuery extends QueryField {
                     const exp = fi.getSQL();
                     if (isScalarField(fi.f)) {
                         if (this.parent.dialect.name === "standardsql" &&
-                            this.rootResult.queryUsesUngrouped) {
+                            this.rootResult.queryUsesPartitioning) {
                             // BigQuery can't partition aggregate function except when the field has no
                             //  expression.  Additionally it can't partition by floats.  We stuff expressions
                             //  and numbers as strings into a lateral join when the query has ungrouped expressions
@@ -1788,7 +1849,7 @@ class QueryQuery extends QueryField {
                         }
                         output.dimensionIndexes.push(output.fieldIndex++);
                     }
-                    else if (isAggregateField(fi.f)) {
+                    else if (isCalculatedField(fi.f)) {
                         output.sql.push(`${exp} as ${outputName}`);
                         output.fieldIndex++;
                     }
@@ -1919,7 +1980,7 @@ class QueryQuery extends QueryField {
                         output.sql.push(`${exp} as ${sqlFieldName}`);
                         output.dimensionIndexes.push(output.fieldIndex++);
                     }
-                    else if (isAggregateField(fi.f)) {
+                    else if (isCalculatedField(fi.f)) {
                         const exp = this.parent.dialect.sqlAnyValue(resultSet.groupSet, sqlFieldName);
                         output.sql.push(`${exp} as ${sqlFieldName}`);
                         output.fieldIndex++;
@@ -1991,7 +2052,7 @@ class QueryQuery extends QueryField {
                         fieldsSQL.push(this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${this.rootResult.groupSet}`) + ` as ${sqlName}`);
                         dimensionIndexes.push(fieldIndex++);
                     }
-                    else if (isAggregateField(fi.f)) {
+                    else if (isCalculatedField(fi.f)) {
                         fieldsSQL.push(this.parent.dialect.sqlAnyValueLastTurtle(name, this.rootResult.groupSet, sqlName));
                         fieldIndex++;
                     }

package/dist/model/malloy_types.d.ts

@@ -111,6 +111,20 @@ export interface UngroupFragment {
     fields?: string[];
 }
 export declare function isUngroupFragment(f: Fragment): f is UngroupFragment;
+export declare type MalloyFunctionParam = AtomicFieldType | "any" | "nconst" | "regexp";
+export interface MalloyFunctionInfo {
+    returnType: AtomicFieldType;
+    parameters: "any" | "none" | MalloyFunctionParam[];
+    expressionType?: "aggregate" | "analytic";
+    sqlName?: string;
+}
+export declare const malloyFunctions: Record<string, MalloyFunctionInfo>;
+export interface AnalyticFragment {
+    type: "analytic";
+    function: string;
+    parameters?: (string | number | Expr)[];
+}
+export declare function isAnalyticFragment(f: Fragment): f is AnalyticFragment;
 export interface FieldFragment {
     type: "field";
     path: string;
@@ -189,7 +203,7 @@ export interface StringLiteralFragment extends DialectFragmentBase {
     literal: string;
 }
 export declare type DialectFragment = DivFragment | TimeLiteralFragment | NowFragment | TimeDeltaFragment | TimeDiffFragment | TimeTruncFragment | TypecastFragment | TimeExtractFragment | StringLiteralFragment | RegexpMatchFragment;
-export declare type Fragment = string | ApplyFragment | ApplyValueFragment | FieldFragment | ParameterFragment | FilterFragment | AggregateFragment | UngroupFragment | DialectFragment;
+export declare type Fragment = string | ApplyFragment | ApplyValueFragment | FieldFragment | ParameterFragment | FilterFragment | AggregateFragment | UngroupFragment | DialectFragment | AnalyticFragment;
 export declare type Expr = Fragment[];
 export interface TypedValue {
     value: Expr;
@@ -210,11 +224,15 @@ declare type TagElement = Expr | string;
  * ```
  */
 export declare function mkExpr(src: TemplateStringsArray, ...exprs: TagElement[]): Expr;
+export declare type ExpressionType = "scalar" | "aggregate" | "analytic";
 export interface Expression {
     e?: Expr;
-    aggregate?: boolean;
+    expressionType?: ExpressionType;
     code?: string;
 }
+export declare function expressionIsAggregate(e: ExpressionType | undefined): boolean;
+export declare function expressionIsCalculation(e: ExpressionType | undefined): boolean;
+export declare function maxExpressionType(e1: ExpressionType, e2: ExpressionType): ExpressionType;
 interface JustExpression {
     e: Expr;
 }
@@ -446,7 +464,7 @@ export declare type PrimaryKeyRef = string;
 export interface FilterExpression {
     expression: Expr;
     code: string;
-    aggregate?: boolean;
+    expressionType: ExpressionType;
 }
 /** Get the output name for a NamedObject */
 export declare function getIdentifier(n: AliasedName): string;

package/dist/model/malloy_types.js

@@ -12,7 +12,8 @@
  * GNU General Public License for more details.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValueDate = exports.isValueTimestamp = exports.isValueBoolean = exports.isValueNumber = exports.isValueString = exports.isMeasureLike = exports.getPhysicalFields = exports.getDimensions = exports.isPhysical = exports.isDimensional = exports.isTurtleDef = exports.getIdentifier = exports.isFieldStructDef = exports.isFieldTimeBased = exports.isFieldTypeDef = exports.isSQLBlock = exports.isSQLFragment = exports.isJoinOn = exports.isIndexSegment = exports.isSamplingEnable = exports.isSamplingPercent = exports.isSamplingRows = exports.isQuerySegment = exports.isProjectSegment = exports.isReduceSegment = exports.refIsStructDef = exports.isByExpression = exports.isByName = exports.ValueType = exports.isExtractUnit = exports.isTimestampUnit = exports.isDateUnit = exports.FieldIsIntrinsic = exports.isAtomicFieldType = exports.isTimeFieldType = exports.hasExpression = exports.mkExpr = exports.isApplyFragment = exports.isApplyValue = exports.isParameterFragment = exports.isFieldFragment = exports.isUngroupFragment = exports.isAsymmetricFragment = exports.isAggregateFragment = exports.isDialectFragment = exports.isFilterFragment = exports.isFilteredAliasedName = exports.paramHasValue = exports.isConditionParameter = exports.isValueParameter = void 0;
+exports.isMeasureLike = exports.getPhysicalFields = exports.getDimensions = exports.isPhysical = exports.isDimensional = exports.isTurtleDef = exports.getIdentifier = exports.isFieldStructDef = exports.isFieldTimeBased = exports.isFieldTypeDef = exports.isSQLBlock = exports.isSQLFragment = exports.isJoinOn = exports.isIndexSegment = exports.isSamplingEnable = exports.isSamplingPercent = exports.isSamplingRows = exports.isQuerySegment = exports.isProjectSegment = exports.isReduceSegment = exports.refIsStructDef = exports.isByExpression = exports.isByName = exports.ValueType = exports.isExtractUnit = exports.isTimestampUnit = exports.isDateUnit = exports.FieldIsIntrinsic = exports.isAtomicFieldType = exports.isTimeFieldType = exports.hasExpression = exports.maxExpressionType = exports.expressionIsCalculation = exports.expressionIsAggregate = exports.mkExpr = exports.isApplyFragment = exports.isApplyValue = exports.isParameterFragment = exports.isFieldFragment = exports.isAnalyticFragment = exports.malloyFunctions = exports.isUngroupFragment = exports.isAsymmetricFragment = exports.isAggregateFragment = exports.isDialectFragment = exports.isFilterFragment = exports.isFilteredAliasedName = exports.paramHasValue = exports.isConditionParameter = exports.isValueParameter = void 0;
+exports.isValueDate = exports.isValueTimestamp = exports.isValueBoolean = exports.isValueNumber = exports.isValueString = void 0;
 function isValueParameter(p) {
     return p.value !== undefined;
 }
@@ -55,6 +56,61 @@ function isUngroupFragment(f) {
     return ftype == "all" || ftype == "exclude";
 }
 exports.isUngroupFragment = isUngroupFragment;
+exports.malloyFunctions = {
+    row_number: {
+        returnType: "number",
+        parameters: "none",
+        expressionType: "analytic",
+    },
+    rank: {
+        returnType: "number",
+        parameters: "none",
+        expressionType: "analytic",
+    },
+    dense_rank: {
+        returnType: "number",
+        parameters: "none",
+        expressionType: "analytic",
+    },
+    first_value_in_column: {
+        returnType: "number",
+        parameters: "any",
+        expressionType: "analytic",
+        sqlName: "first_value",
+    },
+    last_value_in_column: {
+        returnType: "number",
+        parameters: "any",
+        expressionType: "analytic",
+        sqlName: "last_value",
+    },
+    min_in_column: {
+        returnType: "number",
+        parameters: "any",
+        expressionType: "analytic",
+        sqlName: "min",
+    },
+    max_in_column: {
+        returnType: "number",
+        parameters: "any",
+        expressionType: "analytic",
+        sqlName: "max",
+    },
+    ntile: {
+        returnType: "number",
+        parameters: ["nconst"],
+        expressionType: "analytic",
+    },
+    lag: {
+        returnType: "number",
+        parameters: ["number", "nconst"],
+        expressionType: "analytic",
+    },
+};
+function isAnalyticFragment(f) {
+    return (f === null || f === void 0 ? void 0 : f.type) === "analytic";
+}
+exports.isAnalyticFragment = isAnalyticFragment;
 function isFieldFragment(f) {
     return (f === null || f === void 0 ? void 0 : f.type) === "field";
 }
@@ -102,6 +158,25 @@ function mkExpr(src, ...exprs) {
     return ret;
 }
 exports.mkExpr = mkExpr;
+function expressionIsAggregate(e) {
+    return e === "aggregate";
+}
+exports.expressionIsAggregate = expressionIsAggregate;
+function expressionIsCalculation(e) {
+    return e === "aggregate" || e === "analytic";
+}
+exports.expressionIsCalculation = expressionIsCalculation;
+function maxExpressionType(e1, e2) {
+    let ret = "scalar";
+    if (e1 === "aggregate" || e2 === "aggregate") {
+        ret = "aggregate";
+    }
+    if (e1 === "analytic" || e2 === "analytic") {
+        ret = "analytic";
+    }
+    return ret;
+}
+exports.maxExpressionType = maxExpressionType;
 /**  Grants access to the expression property of a FielfDef */
 function hasExpression(f) {
     return f.e !== undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.16-dev230104154319",
+  "version": "0.0.16",
   "license": "GPL-2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",