@malloydata/malloy 0.0.122 → 0.0.123-dev240205152128

package/dist/dialect/dialect_map.js

@@ -86,6 +86,7 @@ function getDialectFunction(name) {
                     existingOverload.dialect[dialect.name] = {
                         e: overload.e,
                         supportsOrderBy: overload.supportsOrderBy,
+                        defaultOrderByArgIndex: overload.defaultOrderByArgIndex,
                         supportsLimit: overload.supportsLimit,
                     };
                     handled = true;
@@ -98,6 +99,7 @@ function getDialectFunction(name) {
                             [dialect.name]: {
                                 e: overload.e,
                                 supportsOrderBy: overload.supportsOrderBy,
+                                defaultOrderByArgIndex: overload.defaultOrderByArgIndex,
                                 supportsLimit: overload.supportsLimit,
                             },
                         },

package/dist/dialect/functions/string_agg.js

@@ -29,8 +29,8 @@ function fnStringAgg() {
     const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
     const orderBy = { type: 'aggregate_order_by' };
     return [
-        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(${value.arg}${orderBy})`, { supportsOrderBy: true }),
-        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(${value.arg}, ${separator.arg}${orderBy})`, { supportsOrderBy: true }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(${value.arg}${orderBy})`, { supportsOrderBy: true, defaultOrderByArgIndex: 0 }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(${value.arg}, ${separator.arg}${orderBy})`, { supportsOrderBy: true, defaultOrderByArgIndex: 0 }),
     ];
 }
 exports.fnStringAgg = fnStringAgg;
@@ -39,8 +39,16 @@ function fnStringAggDistinct() {
     const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
     const orderBy = { type: 'aggregate_order_by' };
     return [
-        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}${orderBy})`, { isSymmetric: true, supportsOrderBy: true }),
-        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}, ${separator.arg}${orderBy})`, { isSymmetric: true, supportsOrderBy: true }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}${orderBy})`, {
+            isSymmetric: true,
+            supportsOrderBy: 'only_default',
+            defaultOrderByArgIndex: 0,
+        }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}, ${separator.arg}${orderBy})`, {
+            isSymmetric: true,
+            supportsOrderBy: 'only_default',
+            defaultOrderByArgIndex: 0,
+        }),
     ];
 }
 exports.fnStringAggDistinct = fnStringAggDistinct;

package/dist/dialect/functions/util.d.ts

@@ -5,7 +5,8 @@ export interface DialectFunctionOverloadDef {
     e: Expr;
     needsWindowOrderBy?: boolean;
     isSymmetric?: boolean;
-    supportsOrderBy?: boolean;
+    supportsOrderBy?: boolean | 'only_default';
+    defaultOrderByArgIndex?: number;
     supportsLimit?: boolean;
     between: {
         preceding: number | string;
@@ -47,5 +48,6 @@ export declare function overload(returnType: TypeDesc, params: FunctionParameter
     };
     isSymmetric?: boolean;
     supportsLimit?: boolean;
-    supportsOrderBy?: boolean;
+    defaultOrderByArgIndex?: number;
+    supportsOrderBy?: boolean | 'only_default';
 }): DialectFunctionOverloadDef;

package/dist/dialect/functions/util.js

@@ -183,6 +183,7 @@ function overload(returnType, params, e, options) {
         between: options === null || options === void 0 ? void 0 : options.between,
         isSymmetric: options === null || options === void 0 ? void 0 : options.isSymmetric,
         supportsOrderBy: options === null || options === void 0 ? void 0 : options.supportsOrderBy,
+        defaultOrderByArgIndex: options === null || options === void 0 ? void 0 : options.defaultOrderByArgIndex,
         supportsLimit: options === null || options === void 0 ? void 0 : options.supportsLimit,
     };
 }

package/dist/dialect/postgres/functions/string_agg.js

@@ -39,8 +39,16 @@ function fnStringAggDistinct() {
     const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
     const orderBy = { type: 'aggregate_order_by' };
     return [
-        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}, ','${orderBy})`, { isSymmetric: true, supportsOrderBy: true }),
-        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}, ${separator.arg}${orderBy})`, { isSymmetric: true, supportsOrderBy: true }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}, ','${orderBy})`, {
+            isSymmetric: true,
+            supportsOrderBy: 'only_default',
+            defaultOrderByArgIndex: 0,
+        }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}, ${separator.arg}${orderBy})`, {
+            isSymmetric: true,
+            supportsOrderBy: 'only_default',
+            defaultOrderByArgIndex: 0,
+        }),
     ];
 }
 exports.fnStringAggDistinct = fnStringAggDistinct;

package/dist/dialect/standardsql/functions/string_agg.js

@@ -30,8 +30,8 @@ function fnStringAgg() {
     const orderBy = { type: 'aggregate_order_by' };
     const limit = { type: 'aggregate_limit' };
     return [
-        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(${value.arg}${orderBy}${limit})`, { supportsOrderBy: true, supportsLimit: true }),
-        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(${value.arg}, ${separator.arg}${orderBy}${limit})`, { supportsOrderBy: true, supportsLimit: true }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(${value.arg}${orderBy}${limit})`, { supportsOrderBy: true, supportsLimit: true, defaultOrderByArgIndex: 0 }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(${value.arg}, ${separator.arg}${orderBy}${limit})`, { supportsOrderBy: true, supportsLimit: true, defaultOrderByArgIndex: 0 }),
     ];
 }
 exports.fnStringAgg = fnStringAgg;
@@ -41,8 +41,18 @@ function fnStringAggDistinct() {
     const orderBy = { type: 'aggregate_order_by' };
     const limit = { type: 'aggregate_limit' };
     return [
-        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}${orderBy}${limit})`, { isSymmetric: true, supportsOrderBy: true, supportsLimit: true }),
-        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}, ${separator.arg}${orderBy}${limit})`, { isSymmetric: true, supportsOrderBy: true, supportsLimit: true }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}${orderBy}${limit})`, {
+            isSymmetric: true,
+            supportsOrderBy: 'only_default',
+            supportsLimit: true,
+            defaultOrderByArgIndex: 0,
+        }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}, ${separator.arg}${orderBy}${limit})`, {
+            isSymmetric: true,
+            supportsOrderBy: 'only_default',
+            supportsLimit: true,
+            defaultOrderByArgIndex: 0,
+        }),
     ];
 }
 exports.fnStringAggDistinct = fnStringAggDistinct;

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

@@ -176,6 +176,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         const frag = {
             type: 'function_call',
             overload,
+            name: this.name,
             args: argExprs.map(x => x.value),
             expressionType,
             structPath,
@@ -193,9 +194,10 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             if ((props === null || props === void 0 ? void 0 : props.orderBys) && props.orderBys.length > 0) {
                 const isAnalytic = (0, malloy_types_1.expressionIsAnalytic)(overload.returnType.expressionType);
                 if (dialectOverload.supportsOrderBy || isAnalytic) {
+                    const allowExpression = dialectOverload.supportsOrderBy !== 'only_default';
                     const allObs = props.orderBys.flatMap(orderBy => isAnalytic
                         ? orderBy.getAnalyticOrderBy(fs)
-                        : orderBy.getAggregateOrderBy(fs));
+                        : orderBy.getAggregateOrderBy(fs, allowExpression));
                     frag.orderBy = allObs;
                 }
                 else {

package/dist/lang/ast/expressions/function-ordering.d.ts

@@ -3,16 +3,16 @@ import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
 import { ListOf, MalloyElement } from '../types/malloy-element';
 export declare class FunctionOrderBy extends MalloyElement {
-    readonly field: ExpressionDef;
+    readonly field?: ExpressionDef | undefined;
     readonly dir?: "asc" | "desc" | undefined;
     elementType: string;
-    constructor(field: ExpressionDef, dir?: "asc" | "desc" | undefined);
+    constructor(field?: ExpressionDef | undefined, dir?: "asc" | "desc" | undefined);
     getAnalyticOrderBy(fs: FieldSpace): ModelFunctionOrderBy;
-    getAggregateOrderBy(fs: FieldSpace): ModelFunctionOrderBy;
+    getAggregateOrderBy(fs: FieldSpace, allowExpression: boolean): ModelFunctionOrderBy;
 }
 export declare class FunctionOrdering extends ListOf<FunctionOrderBy> {
     elementType: string;
     constructor(list: FunctionOrderBy[]);
     getAnalyticOrderBy(fs: FieldSpace): ModelFunctionOrderBy[];
-    getAggregateOrderBy(fs: FieldSpace): ModelFunctionOrderBy[];
+    getAggregateOrderBy(fs: FieldSpace, allowExpression: boolean): ModelFunctionOrderBy[];
 }

package/dist/lang/ast/expressions/function-ordering.js

@@ -32,9 +32,14 @@ class FunctionOrderBy extends malloy_element_1.MalloyElement {
         this.field = field;
         this.dir = dir;
         this.elementType = 'orderBy';
-        this.has({ field });
+        if (field)
+            this.has({ field });
     }
     getAnalyticOrderBy(fs) {
+        if (!this.field) {
+            this.log('analytic `order_by` must specify an aggregate expression or output field reference');
+            return { e: ['error'], dir: this.dir };
+        }
         const expr = this.field.getExpression(fs);
         if ((0, malloy_types_1.expressionIsAggregate)(expr.expressionType)) {
             // Aggregates are okay
@@ -50,12 +55,25 @@ class FunctionOrderBy extends malloy_element_1.MalloyElement {
         }
         return { e: expr.value, dir: this.dir };
     }
-    getAggregateOrderBy(fs) {
-        const expr = this.field.getExpression(fs);
-        if (!(0, malloy_types_1.expressionIsScalar)(expr.expressionType)) {
-            this.field.log('aggregate `order_by` must be scalar');
+    getAggregateOrderBy(fs, allowExpression) {
+        if (this.field) {
+            const expr = this.field.getExpression(fs);
+            if (!(0, malloy_types_1.expressionIsScalar)(expr.expressionType)) {
+                this.field.log('aggregate `order_by` must be scalar');
+            }
+            if (!allowExpression) {
+                this.field.log('`order_by` must be only `asc` or `desc` with no expression');
+            }
+            return { e: expr.value, dir: this.dir };
+        }
+        else {
+            if (this.dir === undefined) {
+                // This error should technically never happen because it can't parse this way
+                this.log('field or order direction must be specified');
+                return { e: undefined, dir: 'asc' };
+            }
+            return { e: undefined, dir: this.dir };
         }
-        return { e: expr.value, dir: this.dir };
     }
 }
 exports.FunctionOrderBy = FunctionOrderBy;
@@ -67,8 +85,8 @@ class FunctionOrdering extends malloy_element_1.ListOf {
     getAnalyticOrderBy(fs) {
         return this.list.map(el => el.getAnalyticOrderBy(fs));
     }
-    getAggregateOrderBy(fs) {
-        return this.list.map(el => el.getAggregateOrderBy(fs));
+    getAggregateOrderBy(fs, allowExpression) {
+        return this.list.map(el => el.getAggregateOrderBy(fs, allowExpression));
     }
 }
 exports.FunctionOrdering = FunctionOrdering;

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

@@ -1346,7 +1346,7 @@ export declare class AggregateOrderingContext extends ParserRuleContext {
     accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
 }
 export declare class AggregateOrderBySpecContext extends ParserRuleContext {
-    fieldExpr(): FieldExprContext;
+    fieldExpr(): FieldExprContext | undefined;
     ASC(): TerminalNode | undefined;
     DESC(): TerminalNode | undefined;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);