@malloydata/malloy 0.0.123-dev240203154014 → 0.0.123-dev240205203117

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-aggregate-function.js

@@ -87,7 +87,8 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                     // locality to be that join path
                     const joinUsage = this.getJoinUsage(inputFS);
                     const allUsagesSame = joinUsage.length === 1 ||
-                        joinUsage.slice(1).every(p => joinPathEq(p, joinUsage[0]));
+                        (joinUsage.length > 1 &&
+                            joinUsage.slice(1).every(p => joinPathEq(p, joinUsage[0])));
                     if (allUsagesSame) {
                         structPath = joinUsage[0].map(p => p.name);
                         sourceRelationship = joinUsage[0];
@@ -227,7 +228,6 @@ function getJoinUsage(fs, expr) {
     };
     (0, utils_1.exprWalk)(expr, frag => {
         if (typeof frag !== 'string') {
-            // TODO make this work for field references inside sql_* functions
             if (frag.type === 'field') {
                 const def = lookup(fs, frag.path);
                 if (def.def.type !== 'struct' && def.def.type !== 'turtle') {
@@ -240,6 +240,15 @@ function getJoinUsage(fs, expr) {
                     }
                 }
             }
+            else if (frag.type === 'source-reference') {
+                if (frag.path) {
+                    const def = lookup(fs, frag.path);
+                    result.push(def.relationship);
+                }
+                else {
+                    result.push([]);
+                }
+            }
         }
     });
     return result;

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/ast/view-elements/qop-desc-view.d.ts

@@ -16,4 +16,5 @@ export declare class QOpDescView extends View {
     pipelineComp(fs: FieldSpace, isNestIn?: QueryOperationSpace): PipelineComp;
     private getOp;
     refine(inputFS: FieldSpace, _pipeline: PipeSegment[], isNestIn: QueryOperationSpace | undefined): PipeSegment[];
+    getImplicitName(): string | undefined;
 }

package/dist/lang/ast/view-elements/qop-desc-view.js

@@ -93,6 +93,9 @@ class QOpDescView extends view_1.View {
         }
         return pipeline;
     }
+    getImplicitName() {
+        return undefined;
+    }
 }
 exports.QOpDescView = QOpDescView;
 //# sourceMappingURL=qop-desc-view.js.map

package/dist/lang/ast/view-elements/reference-view.d.ts

@@ -24,4 +24,5 @@ export declare class ReferenceView extends View {
     };
     private getRefinementSegment;
     refine(inputFS: FieldSpace, pipeline: PipeSegment[], _isNestIn: QueryOperationSpace | undefined): PipeSegment[];
+    getImplicitName(): string | undefined;
 }

package/dist/lang/ast/view-elements/reference-view.js

@@ -142,6 +142,9 @@ class ReferenceView extends view_1.View {
         // TODO better error pipeline
         return pipeline;
     }
+    getImplicitName() {
+        return this.reference.nameString;
+    }
 }
 exports.ReferenceView = ReferenceView;
 //# sourceMappingURL=reference-view.js.map

package/dist/lang/ast/view-elements/view-arrow.d.ts

@@ -16,4 +16,5 @@ export declare class ViewArrow extends View {
     constructor(base: View, operation: View);
     pipelineComp(fs: FieldSpace): PipelineComp;
     refine(_inputFS: FieldSpace, _pipeline: PipeSegment[], _isNestIn: QueryOperationSpace | undefined): PipeSegment[];
+    getImplicitName(): string | undefined;
 }

package/dist/lang/ast/view-elements/view-arrow.js

@@ -51,6 +51,9 @@ class ViewArrow extends view_1.View {
         this.log('A multi-segment view cannot be used as a refinement');
         return [];
     }
+    getImplicitName() {
+        return this.operation.getImplicitName();
+    }
 }
 exports.ViewArrow = ViewArrow;
 //# sourceMappingURL=view-arrow.js.map

package/dist/lang/ast/view-elements/view-refine.d.ts

@@ -16,4 +16,5 @@ export declare class ViewRefine extends View {
     constructor(base: View, refinement: View);
     pipelineComp(fs: FieldSpace, isNestIn?: QueryOperationSpace): PipelineComp;
     refine(inputFS: FieldSpace, pipeline: PipeSegment[], isNestIn: QueryOperationSpace | undefined): PipeSegment[];
+    getImplicitName(): string | undefined;
 }

package/dist/lang/ast/view-elements/view-refine.js

@@ -60,6 +60,9 @@ class ViewRefine extends view_1.View {
         }
         return (0, refine_utils_1.refine)(this, pipeline, refineFrom[0]);
     }
+    getImplicitName() {
+        return this.base.getImplicitName();
+    }
 }
 exports.ViewRefine = ViewRefine;
 //# sourceMappingURL=view-refine.js.map

package/dist/lang/ast/view-elements/view.d.ts

@@ -22,4 +22,5 @@ export declare abstract class View extends MalloyElement {
     abstract pipelineComp(fs: FieldSpace, isNestIn?: QueryOperationSpace): PipelineComp;
     pipeline(fs: FieldSpace, isNestIn?: QueryOperationSpace): PipeSegment[];
     abstract refine(inputFS: FieldSpace, pipeline: PipeSegment[], isNestIn: QueryOperationSpace | undefined): PipeSegment[];
+    abstract getImplicitName(): string | undefined;
 }

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);
@@ -1532,21 +1532,11 @@ export declare class NestEntryContext extends ParserRuleContext {
     get ruleIndex(): number;
     copyFrom(ctx: NestEntryContext): void;
 }
-export declare class NestExistingContext extends NestEntryContext {
-    tags(): TagsContext;
-    fieldPath(): FieldPathContext;
-    PLUS(): TerminalNode | undefined;
-    vExpr(): VExprContext | undefined;
-    constructor(ctx: NestEntryContext);
-    enterRule(listener: MalloyParserListener): void;
-    exitRule(listener: MalloyParserListener): void;
-    accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
-}
 export declare class NestDefContext extends NestEntryContext {
     tags(): TagsContext;
-    queryName(): QueryNameContext;
-    isDefine(): IsDefineContext;
     vExpr(): VExprContext;
+    queryName(): QueryNameContext | undefined;
+    isDefine(): IsDefineContext | undefined;
     constructor(ctx: NestEntryContext);
     enterRule(listener: MalloyParserListener): void;
     exitRule(listener: MalloyParserListener): void;