@malloydata/malloy 0.0.120-dev240131220408 → 0.0.120

package/dist/lang/lib/Malloy/MalloyParserListener.d.ts

@@ -22,7 +22,7 @@ import { TableMethodContext } from "./MalloyParser";
 import { NestExistingContext } from "./MalloyParser";
 import { NestDefContext } from "./MalloyParser";
 import { ExprFieldPathContext } from "./MalloyParser";
-import { ExprFilterContext } from "./MalloyParser";
+import { ExprFieldPropsContext } from "./MalloyParser";
 import { ExprLiteralContext } from "./MalloyParser";
 import { ExprDurationContext } from "./MalloyParser";
 import { ExprTimeTruncContext } from "./MalloyParser";
@@ -68,8 +68,6 @@ import { DefExploreQueryContext } from "./MalloyParser";
 import { DefExploreTimezoneContext } from "./MalloyParser";
 import { DefExploreAnnotationContext } from "./MalloyParser";
 import { DefIgnoreModel_stubContext } from "./MalloyParser";
-import { FilterByShortcutContext } from "./MalloyParser";
-import { FilterByWhereContext } from "./MalloyParser";
 import { JoinWithContext } from "./MalloyParser";
 import { JoinOnContext } from "./MalloyParser";
 import { SQIDContext } from "./MalloyParser";
@@ -139,7 +137,12 @@ import { MatrixOperationContext } from "./MalloyParser";
 import { JoinDefContext } from "./MalloyParser";
 import { JoinExpressionContext } from "./MalloyParser";
 import { FilterStatementContext } from "./MalloyParser";
-import { FilteredByContext } from "./MalloyParser";
+import { FieldPropertiesContext } from "./MalloyParser";
+import { AggregateOrderingContext } from "./MalloyParser";
+import { AggregateOrderBySpecContext } from "./MalloyParser";
+import { AggregateOrderByStatementContext } from "./MalloyParser";
+import { FieldPropertyLimitStatementContext } from "./MalloyParser";
+import { FieldPropertyStatementContext } from "./MalloyParser";
 import { FilterClauseListContext } from "./MalloyParser";
 import { WhereStatementContext } from "./MalloyParser";
 import { HavingStatementContext } from "./MalloyParser";
@@ -157,6 +160,7 @@ import { NestEntryContext } from "./MalloyParser";
 import { AggregateStatementContext } from "./MalloyParser";
 import { CalculateStatementContext } from "./MalloyParser";
 import { ProjectStatementContext } from "./MalloyParser";
+import { PartitionByStatementContext } from "./MalloyParser";
 import { OrderByStatementContext } from "./MalloyParser";
 import { OrderingContext } from "./MalloyParser";
 import { OrderBySpecContext } from "./MalloyParser";
@@ -486,17 +490,17 @@ export interface MalloyParserListener extends ParseTreeListener {
      */
     exitExprFieldPath?: (ctx: ExprFieldPathContext) => void;
     /**
-     * Enter a parse tree produced by the `exprFilter`
+     * Enter a parse tree produced by the `exprFieldProps`
      * labeled alternative in `MalloyParser.fieldExpr`.
      * @param ctx the parse tree
      */
-    enterExprFilter?: (ctx: ExprFilterContext) => void;
+    enterExprFieldProps?: (ctx: ExprFieldPropsContext) => void;
     /**
-     * Exit a parse tree produced by the `exprFilter`
+     * Exit a parse tree produced by the `exprFieldProps`
      * labeled alternative in `MalloyParser.fieldExpr`.
      * @param ctx the parse tree
      */
-    exitExprFilter?: (ctx: ExprFilterContext) => void;
+    exitExprFieldProps?: (ctx: ExprFieldPropsContext) => void;
     /**
      * Enter a parse tree produced by the `exprLiteral`
      * labeled alternative in `MalloyParser.fieldExpr`.
@@ -1037,30 +1041,6 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitDefIgnoreModel_stub?: (ctx: DefIgnoreModel_stubContext) => void;
-    /**
-     * Enter a parse tree produced by the `filterByShortcut`
-     * labeled alternative in `MalloyParser.filteredBy`.
-     * @param ctx the parse tree
-     */
-    enterFilterByShortcut?: (ctx: FilterByShortcutContext) => void;
-    /**
-     * Exit a parse tree produced by the `filterByShortcut`
-     * labeled alternative in `MalloyParser.filteredBy`.
-     * @param ctx the parse tree
-     */
-    exitFilterByShortcut?: (ctx: FilterByShortcutContext) => void;
-    /**
-     * Enter a parse tree produced by the `filterByWhere`
-     * labeled alternative in `MalloyParser.filteredBy`.
-     * @param ctx the parse tree
-     */
-    enterFilterByWhere?: (ctx: FilterByWhereContext) => void;
-    /**
-     * Exit a parse tree produced by the `filterByWhere`
-     * labeled alternative in `MalloyParser.filteredBy`.
-     * @param ctx the parse tree
-     */
-    exitFilterByWhere?: (ctx: FilterByWhereContext) => void;
     /**
      * Enter a parse tree produced by the `joinWith`
      * labeled alternative in `MalloyParser.joinDef`.
@@ -1770,15 +1750,65 @@ export interface MalloyParserListener extends ParseTreeListener {
      */
     exitFilterStatement?: (ctx: FilterStatementContext) => void;
     /**
-     * Enter a parse tree produced by `MalloyParser.filteredBy`.
+     * Enter a parse tree produced by `MalloyParser.fieldProperties`.
+     * @param ctx the parse tree
+     */
+    enterFieldProperties?: (ctx: FieldPropertiesContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.fieldProperties`.
+     * @param ctx the parse tree
+     */
+    exitFieldProperties?: (ctx: FieldPropertiesContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.aggregateOrdering`.
+     * @param ctx the parse tree
+     */
+    enterAggregateOrdering?: (ctx: AggregateOrderingContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.aggregateOrdering`.
+     * @param ctx the parse tree
+     */
+    exitAggregateOrdering?: (ctx: AggregateOrderingContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.aggregateOrderBySpec`.
      * @param ctx the parse tree
      */
-    enterFilteredBy?: (ctx: FilteredByContext) => void;
+    enterAggregateOrderBySpec?: (ctx: AggregateOrderBySpecContext) => void;
     /**
-     * Exit a parse tree produced by `MalloyParser.filteredBy`.
+     * Exit a parse tree produced by `MalloyParser.aggregateOrderBySpec`.
      * @param ctx the parse tree
      */
-    exitFilteredBy?: (ctx: FilteredByContext) => void;
+    exitAggregateOrderBySpec?: (ctx: AggregateOrderBySpecContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.aggregateOrderByStatement`.
+     * @param ctx the parse tree
+     */
+    enterAggregateOrderByStatement?: (ctx: AggregateOrderByStatementContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.aggregateOrderByStatement`.
+     * @param ctx the parse tree
+     */
+    exitAggregateOrderByStatement?: (ctx: AggregateOrderByStatementContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.fieldPropertyLimitStatement`.
+     * @param ctx the parse tree
+     */
+    enterFieldPropertyLimitStatement?: (ctx: FieldPropertyLimitStatementContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.fieldPropertyLimitStatement`.
+     * @param ctx the parse tree
+     */
+    exitFieldPropertyLimitStatement?: (ctx: FieldPropertyLimitStatementContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.fieldPropertyStatement`.
+     * @param ctx the parse tree
+     */
+    enterFieldPropertyStatement?: (ctx: FieldPropertyStatementContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.fieldPropertyStatement`.
+     * @param ctx the parse tree
+     */
+    exitFieldPropertyStatement?: (ctx: FieldPropertyStatementContext) => void;
     /**
      * Enter a parse tree produced by `MalloyParser.filterClauseList`.
      * @param ctx the parse tree
@@ -1949,6 +1979,16 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitProjectStatement?: (ctx: ProjectStatementContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.partitionByStatement`.
+     * @param ctx the parse tree
+     */
+    enterPartitionByStatement?: (ctx: PartitionByStatementContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.partitionByStatement`.
+     * @param ctx the parse tree
+     */
+    exitPartitionByStatement?: (ctx: PartitionByStatementContext) => void;
     /**
      * Enter a parse tree produced by `MalloyParser.orderByStatement`.
      * @param ctx the parse tree

package/dist/lang/lib/Malloy/MalloyParserVisitor.d.ts

@@ -22,7 +22,7 @@ import { TableMethodContext } from "./MalloyParser";
 import { NestExistingContext } from "./MalloyParser";
 import { NestDefContext } from "./MalloyParser";
 import { ExprFieldPathContext } from "./MalloyParser";
-import { ExprFilterContext } from "./MalloyParser";
+import { ExprFieldPropsContext } from "./MalloyParser";
 import { ExprLiteralContext } from "./MalloyParser";
 import { ExprDurationContext } from "./MalloyParser";
 import { ExprTimeTruncContext } from "./MalloyParser";
@@ -68,8 +68,6 @@ import { DefExploreQueryContext } from "./MalloyParser";
 import { DefExploreTimezoneContext } from "./MalloyParser";
 import { DefExploreAnnotationContext } from "./MalloyParser";
 import { DefIgnoreModel_stubContext } from "./MalloyParser";
-import { FilterByShortcutContext } from "./MalloyParser";
-import { FilterByWhereContext } from "./MalloyParser";
 import { JoinWithContext } from "./MalloyParser";
 import { JoinOnContext } from "./MalloyParser";
 import { SQIDContext } from "./MalloyParser";
@@ -139,7 +137,12 @@ import { MatrixOperationContext } from "./MalloyParser";
 import { JoinDefContext } from "./MalloyParser";
 import { JoinExpressionContext } from "./MalloyParser";
 import { FilterStatementContext } from "./MalloyParser";
-import { FilteredByContext } from "./MalloyParser";
+import { FieldPropertiesContext } from "./MalloyParser";
+import { AggregateOrderingContext } from "./MalloyParser";
+import { AggregateOrderBySpecContext } from "./MalloyParser";
+import { AggregateOrderByStatementContext } from "./MalloyParser";
+import { FieldPropertyLimitStatementContext } from "./MalloyParser";
+import { FieldPropertyStatementContext } from "./MalloyParser";
 import { FilterClauseListContext } from "./MalloyParser";
 import { WhereStatementContext } from "./MalloyParser";
 import { HavingStatementContext } from "./MalloyParser";
@@ -157,6 +160,7 @@ import { NestEntryContext } from "./MalloyParser";
 import { AggregateStatementContext } from "./MalloyParser";
 import { CalculateStatementContext } from "./MalloyParser";
 import { ProjectStatementContext } from "./MalloyParser";
+import { PartitionByStatementContext } from "./MalloyParser";
 import { OrderByStatementContext } from "./MalloyParser";
 import { OrderingContext } from "./MalloyParser";
 import { OrderBySpecContext } from "./MalloyParser";
@@ -374,12 +378,12 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      */
     visitExprFieldPath?: (ctx: ExprFieldPathContext) => Result;
     /**
-     * Visit a parse tree produced by the `exprFilter`
+     * Visit a parse tree produced by the `exprFieldProps`
      * labeled alternative in `MalloyParser.fieldExpr`.
      * @param ctx the parse tree
      * @return the visitor result
      */
-    visitExprFilter?: (ctx: ExprFilterContext) => Result;
+    visitExprFieldProps?: (ctx: ExprFieldPropsContext) => Result;
     /**
      * Visit a parse tree produced by the `exprLiteral`
      * labeled alternative in `MalloyParser.fieldExpr`.
@@ -695,20 +699,6 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitDefIgnoreModel_stub?: (ctx: DefIgnoreModel_stubContext) => Result;
-    /**
-     * Visit a parse tree produced by the `filterByShortcut`
-     * labeled alternative in `MalloyParser.filteredBy`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitFilterByShortcut?: (ctx: FilterByShortcutContext) => Result;
-    /**
-     * Visit a parse tree produced by the `filterByWhere`
-     * labeled alternative in `MalloyParser.filteredBy`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitFilterByWhere?: (ctx: FilterByWhereContext) => Result;
     /**
      * Visit a parse tree produced by the `joinWith`
      * labeled alternative in `MalloyParser.joinDef`.
@@ -1133,11 +1123,41 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      */
     visitFilterStatement?: (ctx: FilterStatementContext) => Result;
     /**
-     * Visit a parse tree produced by `MalloyParser.filteredBy`.
+     * Visit a parse tree produced by `MalloyParser.fieldProperties`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitFieldProperties?: (ctx: FieldPropertiesContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.aggregateOrdering`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitAggregateOrdering?: (ctx: AggregateOrderingContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.aggregateOrderBySpec`.
      * @param ctx the parse tree
      * @return the visitor result
      */
-    visitFilteredBy?: (ctx: FilteredByContext) => Result;
+    visitAggregateOrderBySpec?: (ctx: AggregateOrderBySpecContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.aggregateOrderByStatement`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitAggregateOrderByStatement?: (ctx: AggregateOrderByStatementContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.fieldPropertyLimitStatement`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitFieldPropertyLimitStatement?: (ctx: FieldPropertyLimitStatementContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.fieldPropertyStatement`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitFieldPropertyStatement?: (ctx: FieldPropertyStatementContext) => Result;
     /**
      * Visit a parse tree produced by `MalloyParser.filterClauseList`.
      * @param ctx the parse tree
@@ -1240,6 +1260,12 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitProjectStatement?: (ctx: ProjectStatementContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.partitionByStatement`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitPartitionByStatement?: (ctx: PartitionByStatementContext) => Result;
     /**
      * Visit a parse tree produced by `MalloyParser.orderByStatement`.
      * @param ctx the parse tree

package/dist/lang/malloy-to-ast.d.ts

@@ -105,7 +105,6 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitExploreRenameDef(pcx: parse.ExploreRenameDefContext): ast.RenameField;
     visitDefExploreRename(pcx: parse.DefExploreRenameContext): ast.Renames;
     visitFilterClauseList(pcx: parse.FilterClauseListContext): ast.Filter;
-    visitFilterByShortcut(pcx: parse.FilterByShortcutContext): ast.Filter;
     visitWhereStatement(pcx: parse.WhereStatementContext): ast.Filter;
     visitHavingStatement(pcx: parse.HavingStatementContext): ast.Filter;
     visitSubQueryDefList(pcx: parse.SubQueryDefListContext): ast.Views;
@@ -130,7 +129,11 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitCollectionWildCard(pcx: parse.CollectionWildCardContext): ast.FieldReferenceElement;
     visitIndexFields(pcx: parse.IndexFieldsContext): ast.FieldReferences;
     visitIndexStatement(pcx: parse.IndexStatementContext): ast.Index;
+    visitFieldPropertyLimitStatement(pcx: parse.FieldPropertyLimitStatementContext): ast.Limit;
     visitLimitStatement(pcx: parse.LimitStatementContext): ast.Limit;
+    visitAggregateOrderBySpec(pcx: parse.AggregateOrderBySpecContext): ast.FunctionOrderBy;
+    visitAggregateOrderByStatement(pcx: parse.AggregateOrderByStatementContext): ast.FunctionOrdering;
+    visitAggregateOrdering(pcx: parse.AggregateOrderingContext): ast.FunctionOrdering;
     visitOrderBySpec(pcx: parse.OrderBySpecContext): ast.OrderBy;
     visitOrdering(pcx: parse.OrderingContext): ast.Ordering;
     visitTopStatement(pcx: parse.TopStatementContext): ast.Top;
@@ -184,7 +187,8 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitExprFunc(pcx: parse.ExprFuncContext): ast.ExpressionDef;
     visitExprDuration(pcx: parse.ExprDurationContext): ast.ExprDuration;
     visitPickStatement(pcx: parse.PickStatementContext): ast.Pick;
-    visitExprFilter(pcx: parse.ExprFilterContext): ast.ExprFilter;
+    visitExprFieldProps(pcx: parse.ExprFieldPropsContext): ast.ExprProps;
+    visitPartitionByStatement(pcx: parse.PartitionByStatementContext): ast.PartitionBy;
     visitLiteralTimestamp(pcx: parse.LiteralTimestampContext): ast.ExpressionDef;
     visitLiteralHour(pcx: parse.LiteralHourContext): ast.ExpressionDef;
     visitLiteralDay(pcx: parse.LiteralDayContext): ast.ExpressionDef;

package/dist/lang/malloy-to-ast.js

@@ -489,12 +489,6 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     visitFilterClauseList(pcx) {
         return new ast.Filter(pcx.fieldExpr().map(f => this.getFilterElement(f)));
     }
-    visitFilterByShortcut(pcx) {
-        const el = this.getFilterElement(pcx.fieldExpr());
-        const res = this.astAt(new ast.Filter([el]), pcx);
-        this.m4advisory(pcx, 'Filter shortcut `{? condition }` is deprecated; use `{ where: condition } instead');
-        return res;
-    }
     visitWhereStatement(pcx) {
         const where = this.visitFilterClauseList(pcx.filterClauseList());
         where.having = false;
@@ -691,9 +685,28 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         }
         return this.astAt(indexStmt, pcx);
     }
+    visitFieldPropertyLimitStatement(pcx) {
+        this.inExperiment('aggregate_limit', pcx);
+        return this.visitLimitStatement(pcx.limitStatement());
+    }
     visitLimitStatement(pcx) {
         return new ast.Limit(this.getNumber(pcx.INTEGER_LITERAL()));
     }
+    visitAggregateOrderBySpec(pcx) {
+        const dir = pcx.ASC() ? 'asc' : pcx.DESC() ? 'desc' : undefined;
+        const f = this.getFieldExpr(pcx.fieldExpr());
+        return this.astAt(new ast.FunctionOrderBy(f, dir), pcx);
+    }
+    visitAggregateOrderByStatement(pcx) {
+        this.inExperiment('function_order_by', pcx);
+        return this.visitAggregateOrdering(pcx.aggregateOrdering());
+    }
+    visitAggregateOrdering(pcx) {
+        const orderList = pcx
+            .aggregateOrderBySpec()
+            .map(o => this.visitAggregateOrderBySpec(o));
+        return this.astAt(new ast.FunctionOrdering(orderList), pcx);
+    }
     visitOrderBySpec(pcx) {
         const dir = pcx.ASC() ? 'asc' : pcx.DESC() ? 'desc' : undefined;
         const ncx = pcx.INTEGER_LITERAL();
@@ -1104,9 +1117,20 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         }
         return new ast.Pick(picks);
     }
-    visitExprFilter(pcx) {
-        const filters = this.visit(pcx.filteredBy());
-        return new ast.ExprFilter(this.getFieldExpr(pcx.fieldExpr()), filters);
+    visitExprFieldProps(pcx) {
+        const statements = this.only(pcx
+            .fieldProperties()
+            .fieldPropertyStatement()
+            .map(scx => this.visit(scx)), x => ast.isFieldPropStatement(x) && x, 'field property statement');
+        return new ast.ExprProps(this.getFieldExpr(pcx.fieldExpr()), statements);
+    }
+    visitPartitionByStatement(pcx) {
+        this.inExperiment('partition_by', pcx);
+        return this.astAt(new ast.PartitionBy(pcx
+            .id()
+            .map(idCx => this.astAt(new ast.PartitionByFieldReference([
+            this.astAt(new ast.FieldName((0, parse_utils_1.idToStr)(idCx)), idCx),
+        ]), idCx))), pcx);
     }
     visitLiteralTimestamp(pcx) {
         return this.parseTime(pcx, ast.LiteralTimestamp.parse);

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

@@ -150,15 +150,6 @@ describe('expressions', () => {
         }
       `).toTranslate();
     });
-    test('shortcut filtered measure m4warning', () => {
-        expect(`
-      ##! m4warnings=warn
-      run: a -> {
-        group_by: ai
-        aggregate: x is avg(ai) {? astr = 'why?' }
-      }
-    `).toTranslateWithWarnings('Filter shortcut `{? condition }` is deprecated; use `{ where: condition } instead');
-    });
     test('correctly flags filtered scalar', () => {
         const e = new test_translator_1.BetaExpression('ai { where: true }');
         expect(e).translationToFailWith('Filtered expression requires an aggregate computation');
@@ -171,6 +162,138 @@ describe('expressions', () => {
         }
       `).translationToFailWith('Filtered expression requires an aggregate computation');
     });
+    describe('expr props', () => {
+        test('props not allowed without experiments enabled', () => {
+            expect((0, test_translator_1.markSource) `
+          run: a -> {
+            group_by: ai
+            group_by: x1 is string_agg(astr) { order_by: ai }
+            group_by: x2 is lag(ai) { partition_by: ai }
+            group_by: x3 is string_agg(astr) { limit: 10 }
+          }
+        `).translationToFailWith("Experimental flag 'function_order_by' required to enable this feature", "Experimental flag 'partition_by' required to enable this feature", "Experimental flag 'aggregate_limit' required to enable this feature");
+        });
+        test('props not allowed on most expressions', () => {
+            expect((0, test_translator_1.markSource) `
+          ##! experimental { function_order_by partition_by aggregate_limit }
+          run: a -> {
+            group_by: x1 is 1 { order_by: ai }
+            group_by: x2 is 1 { partition_by: ai }
+            group_by: x3 is 1 { limit: 10 }
+            group_by: x4 is 1 { where: ai }
+          }
+        `).translationToFailWith('`order_by` is not supported for this kind of expression', '`partition_by` is not supported for this kind of expression', '`limit` is not supported for this kind of expression', 'Filtered expression requires an aggregate computation');
+        });
+        test('analytics can take parititon_by and order_by', () => {
+            expect((0, test_translator_1.markSource) `
+        ##! experimental { function_order_by partition_by }
+        run: a -> {
+          group_by: ai
+          calculate: x is lag(ai) { partition_by: ai; order_by: ai }
+        }
+      `).toTranslate();
+        });
+        test('can specify multiple partition_bys', () => {
+            expect((0, test_translator_1.markSource) `
+        ##! experimental { partition_by }
+        run: a -> {
+          group_by: ai, astr, abool
+          calculate: x is lag(ai) {
+            partition_by: ai
+            partition_by: astr, abool
+          }
+        }
+      `).toTranslate();
+        });
+        test('can specify multiple order_bys', () => {
+            expect((0, test_translator_1.markSource) `
+        ##! experimental { function_order_by }
+        run: a -> {
+          group_by: ai, astr, abool
+          calculate: x is lag(ai) {
+            order_by: ai
+            order_by: astr, abool
+          }
+        }
+      `).toTranslate();
+        });
+        test('aggregate order by cannot be aggregate', () => {
+            expect((0, test_translator_1.markSource) `
+        ##! experimental { function_order_by }
+        run: a -> {
+          aggregate: x is string_agg(astr) {
+            order_by: sum(ai)
+          }
+        }
+      `).translationToFailWith('aggregate `order_by` must be scalar');
+        });
+        test('aggregate order by cannot be analytic', () => {
+            expect((0, test_translator_1.markSource) `
+        ##! experimental { function_order_by }
+        run: a -> {
+          aggregate: x is string_agg(astr) {
+            order_by: rank()
+          }
+        }
+      `).translationToFailWith('aggregate `order_by` must be scalar');
+        });
+        test('analytic order by can be an aggregate', () => {
+            expect((0, test_translator_1.markSource) `
+        ##! experimental { function_order_by }
+        run: a -> {
+          group_by: abool
+          calculate: x is lag(abool) {
+            order_by: sum(ai)
+          }
+        }
+      `).toTranslate();
+        });
+        test('analytic order by can be an output field', () => {
+            expect((0, test_translator_1.markSource) `
+        ##! experimental { function_order_by }
+        run: a -> {
+          group_by: ai
+          calculate: x is lag(ai) {
+            order_by: ai
+          }
+        }
+      `).toTranslate();
+        });
+        test('analytic order by must be an output field', () => {
+            expect((0, test_translator_1.markSource) `
+        ##! experimental { function_order_by }
+        run: a -> {
+          group_by: abool
+          calculate: x is lag(abool) {
+            order_by: ai
+          }
+        }
+      `).translationToFailWith('analytic `order_by` must be an aggregate or an output field reference');
+        });
+        test('can specify multiple wheres', () => {
+            expect((0, test_translator_1.markSource) `
+        ##! experimental { function_order_by }
+        run: a -> {
+          aggregate: x is count() {
+            where: ai > 10
+            where: astr ~ '%foo%'
+          }
+        }
+      `).toTranslate();
+        });
+        test('string_agg can take order_by', () => {
+            expect((0, test_translator_1.markSource) `
+        ##! experimental { function_order_by }
+        run: a -> {
+          aggregate: x1 is string_agg(astr) { order_by: ai }
+          aggregate: x2 is string_agg(astr) { order_by: ai * 2 }
+          aggregate: x3 is string_agg(astr) { order_by: ai desc }
+          aggregate: x4 is string_agg(astr) { order_by: ai asc }
+          aggregate: x5 is string_agg(astr) { order_by: ai asc, ai }
+        }
+      `).toTranslate();
+        });
+    });
     describe('aggregate forms', () => {
         const m = (0, test_translator_1.model) `
       source: root is a extend {

package/dist/model/malloy_query.d.ts

@@ -85,8 +85,8 @@ declare class QueryField extends QueryNode {
     generateDialect(resultSet: FieldInstanceResult, context: QueryStruct, expr: DialectFragment, state: GenerateState): string;
     generateSqlString(resultSet: FieldInstanceResult, context: QueryStruct, expr: SqlStringFragment, state: GenerateState): string;
     generateSourceReference(resultSet: FieldInstanceResult, context: QueryStruct, expr: SourceReferenceFragment): string;
-    getAnalyticPartitions(resultStruct: FieldInstanceResult): string;
-    generateAnalyticFragment(resultStruct: FieldInstanceResult, context: QueryStruct, expr: Expr, overload: FunctionOverloadDef, state: GenerateState, args: Expr[]): string;
+    getAnalyticPartitions(resultStruct: FieldInstanceResult, extraPartitionFields?: string[]): string[];
+    generateAnalyticFragment(resultStruct: FieldInstanceResult, context: QueryStruct, expr: Expr, overload: FunctionOverloadDef, state: GenerateState, args: Expr[], partitionByFields?: string[], funcOrdering?: string): string;
     generateExpressionFromExpr(resultSet: FieldInstanceResult, context: QueryStruct, e: Expr, state?: GenerateState): string;
     getExpr(): Expr;
     generateExpression(resultSet: FieldInstanceResult): string;