@malloydata/malloy 0.0.198-dev241010005107 → 0.0.198-dev241010181909

package/dist/lang/ast/expressions/case.d.ts

@@ -0,0 +1,18 @@
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
+import { MalloyElement } from '../types/malloy-element';
+export declare class Case extends ExpressionDef {
+    readonly value: ExpressionDef | undefined;
+    readonly choices: CaseWhen[];
+    readonly elseValue?: ExpressionDef | undefined;
+    elementType: string;
+    constructor(value: ExpressionDef | undefined, choices: CaseWhen[], elseValue?: ExpressionDef | undefined);
+    getExpression(fs: FieldSpace): ExprValue;
+}
+export declare class CaseWhen extends MalloyElement {
+    readonly when: ExpressionDef;
+    readonly then: ExpressionDef;
+    elementType: string;
+    constructor(when: ExpressionDef, then: ExpressionDef);
+}

package/dist/lang/ast/expressions/case.js

@@ -0,0 +1,114 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaseWhen = exports.Case = void 0;
+const expression_def_1 = require("../types/expression-def");
+const malloy_element_1 = require("../types/malloy-element");
+const fragtype_utils_1 = require("../fragtype-utils");
+const model_1 = require("../../../model");
+function typeCoalesce(ev1, ev2) {
+    return ev1 === undefined ||
+        ev1.dataType === 'null' ||
+        ev1.dataType === 'error'
+        ? ev2
+        : ev1;
+}
+class Case extends expression_def_1.ExpressionDef {
+    constructor(value, choices, elseValue) {
+        super({ choices });
+        this.value = value;
+        this.choices = choices;
+        this.elseValue = elseValue;
+        this.elementType = 'case';
+        this.has({ elseValue, value });
+    }
+    getExpression(fs) {
+        var _a;
+        const resultExpr = {
+            node: 'case',
+            kids: {
+                caseWhen: [],
+                caseThen: [],
+            },
+        };
+        let expressionType = 'scalar';
+        let evalSpace = 'constant';
+        let value = undefined;
+        if (this.value) {
+            value = this.value.getExpression(fs);
+            expressionType = (0, model_1.maxExpressionType)(expressionType, value.expressionType);
+            evalSpace = (0, model_1.mergeEvalSpaces)(evalSpace, value.evalSpace);
+            resultExpr.kids.caseValue = value.value;
+        }
+        const choiceValues = [];
+        for (const c of this.choices) {
+            const when = c.when.getExpression(fs);
+            const then = c.then.getExpression(fs);
+            choiceValues.push({ when, then });
+        }
+        let returnType;
+        for (const aChoice of choiceValues) {
+            if (value !== undefined) {
+                if (!fragtype_utils_1.FT.typeEq(aChoice.when, value)) {
+                    return this.loggedErrorExpr('case-when-type-does-not-match', {
+                        whenType: aChoice.when.dataType,
+                        valueType: value.dataType,
+                    });
+                }
+            }
+            else {
+                if (!fragtype_utils_1.FT.typeEq(aChoice.when, fragtype_utils_1.FT.boolT)) {
+                    return this.loggedErrorExpr('case-when-must-be-boolean', {
+                        whenType: aChoice.when.dataType,
+                    });
+                }
+            }
+            if (returnType && !fragtype_utils_1.FT.typeEq(returnType, aChoice.then, true)) {
+                return this.loggedErrorExpr('case-then-type-does-not-match', {
+                    thenType: aChoice.then.dataType,
+                    returnType: returnType.dataType,
+                });
+            }
+            returnType = typeCoalesce(returnType, aChoice.then);
+            expressionType = (0, model_1.maxExpressionType)(expressionType, (0, model_1.maxExpressionType)(aChoice.then.expressionType, aChoice.when.expressionType));
+            evalSpace = (0, model_1.mergeEvalSpaces)(evalSpace, aChoice.then.evalSpace, aChoice.when.evalSpace);
+            resultExpr.kids.caseWhen.push(aChoice.when.value);
+            resultExpr.kids.caseThen.push(aChoice.then.value);
+        }
+        if (this.elseValue) {
+            const elseValue = this.elseValue.getExpression(fs);
+            if (returnType && !fragtype_utils_1.FT.typeEq(returnType, elseValue, true)) {
+                return this.loggedErrorExpr('case-else-type-does-not-match', {
+                    elseType: elseValue.dataType,
+                    returnType: returnType.dataType,
+                });
+            }
+            returnType = typeCoalesce(returnType, elseValue);
+            expressionType = (0, model_1.maxExpressionType)(expressionType, elseValue.expressionType);
+            evalSpace = (0, model_1.mergeEvalSpaces)(evalSpace, elseValue.evalSpace);
+            resultExpr.kids.caseElse = elseValue.value;
+        }
+        return {
+            value: resultExpr,
+            dataType: (_a = returnType === null || returnType === void 0 ? void 0 : returnType.dataType) !== null && _a !== void 0 ? _a : 'null',
+            expressionType,
+            evalSpace,
+        };
+    }
+}
+exports.Case = Case;
+class CaseWhen extends malloy_element_1.MalloyElement {
+    constructor(when, then) {
+        super({ when, then });
+        this.when = when;
+        this.then = then;
+        this.elementType = 'caseWhen';
+    }
+}
+exports.CaseWhen = CaseWhen;
+//# sourceMappingURL=case.js.map

package/dist/lang/ast/expressions/pick-when.js

@@ -62,11 +62,10 @@ class Pick extends expression_def_1.ExpressionDef {
     }
     apply(fs, op, expr) {
         const caseValue = {
-            node: 'pick',
+            node: 'case',
             kids: {
-                pickWhen: [],
-                pickThen: [],
-                pickElse: { node: 'error', message: 'pick statement not complete' },
+                caseWhen: [],
+                caseThen: [],
             },
         };
         let returnType;
@@ -86,8 +85,8 @@ class Pick extends expression_def_1.ExpressionDef {
                 });
             }
             returnType = typeCoalesce(returnType, thenExpr);
-            caseValue.kids.pickWhen.push(whenExpr.value);
-            caseValue.kids.pickThen.push(thenExpr.value);
+            caseValue.kids.caseWhen.push(whenExpr.value);
+            caseValue.kids.caseThen.push(thenExpr.value);
         }
         const elsePart = this.elsePick || expr;
         const elseVal = elsePart.getExpression(fs);
@@ -106,7 +105,7 @@ class Pick extends expression_def_1.ExpressionDef {
                 });
             }
         }
-        caseValue.kids.pickElse = elseVal.value;
+        caseValue.kids.caseElse = elseVal.value;
         return {
             dataType: returnType.dataType,
             expressionType: (0, malloy_types_1.maxExpressionType)(anyExpressionType, elseVal.expressionType),
@@ -116,11 +115,10 @@ class Pick extends expression_def_1.ExpressionDef {
     }
     getExpression(fs) {
         const pick = {
-            node: 'pick',
+            node: 'case',
             kids: {
-                pickWhen: [],
-                pickThen: [],
-                pickElse: { node: 'error', message: 'pick statement not complete' },
+                caseWhen: [],
+                caseThen: [],
             },
         };
         if (this.elsePick === undefined) {
@@ -131,8 +129,8 @@ class Pick extends expression_def_1.ExpressionDef {
             if (c.pick === undefined) {
                 return this.loggedErrorExpr('pick-missing-value', 'pick with no value can only be used with apply');
             }
-            const pickWhen = c.when.requestExpression(fs);
-            if (pickWhen === undefined) {
+            const caseWhen = c.when.requestExpression(fs);
+            if (caseWhen === undefined) {
                 this.loggedErrorExpr('pick-illegal-partial', 'pick with partial when can only be used with apply');
             }
             choiceValues.push({
@@ -158,8 +156,8 @@ class Pick extends expression_def_1.ExpressionDef {
             returnType = typeCoalesce(returnType, aChoice.pick);
             anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(aChoice.pick.expressionType, aChoice.when.expressionType));
             anyEvalSpace = (0, malloy_types_1.mergeEvalSpaces)(anyEvalSpace, aChoice.pick.evalSpace, aChoice.when.evalSpace);
-            pick.kids.pickWhen.push(aChoice.when.value);
-            pick.kids.pickThen.push(aChoice.pick.value);
+            pick.kids.caseWhen.push(aChoice.when.value);
+            pick.kids.caseThen.push(aChoice.pick.value);
         }
         const defVal = this.elsePick.getExpression(fs);
         anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, defVal.expressionType);
@@ -171,7 +169,7 @@ class Pick extends expression_def_1.ExpressionDef {
                 returnType: returnType.dataType,
             });
         }
-        pick.kids.pickElse = defVal.value;
+        pick.kids.caseElse = defVal.value;
         return {
             dataType: returnType.dataType,
             expressionType: anyExpressionType,
@@ -186,7 +184,7 @@ class PickWhen extends malloy_element_1.MalloyElement {
         super({ when: when });
         this.pick = pick;
         this.when = when;
-        this.elementType = 'pickWhen';
+        this.elementType = 'caseWhen';
         this.has({ pick: pick });
     }
 }

package/dist/lang/ast/index.d.ts

@@ -52,6 +52,7 @@ export * from './expressions/time-literal';
 export * from './expressions/partial-compare';
 export * from './expressions/partition_by';
 export * from './expressions/pick-when';
+export * from './expressions/case';
 export * from './expressions/expr-record-literal';
 export * from './expressions/range';
 export * from './expressions/time-frame';

package/dist/lang/ast/index.js

@@ -90,6 +90,7 @@ __exportStar(require("./expressions/time-literal"), exports);
 __exportStar(require("./expressions/partial-compare"), exports);
 __exportStar(require("./expressions/partition_by"), exports);
 __exportStar(require("./expressions/pick-when"), exports);
+__exportStar(require("./expressions/case"), exports);
 __exportStar(require("./expressions/expr-record-literal"), exports);
 __exportStar(require("./expressions/range"), exports);
 __exportStar(require("./expressions/time-frame"), exports);

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

@@ -281,24 +281,26 @@ export declare class MalloyParser extends Parser {
     static readonly RULE_partialAllowedFieldExpr = 115;
     static readonly RULE_pickStatement = 116;
     static readonly RULE_pick = 117;
-    static readonly RULE_recordKey = 118;
-    static readonly RULE_recordElement = 119;
-    static readonly RULE_argumentList = 120;
-    static readonly RULE_fieldNameList = 121;
-    static readonly RULE_fieldCollection = 122;
-    static readonly RULE_collectionWildCard = 123;
-    static readonly RULE_starQualified = 124;
-    static readonly RULE_taggedRef = 125;
-    static readonly RULE_refExpr = 126;
-    static readonly RULE_collectionMember = 127;
-    static readonly RULE_fieldPath = 128;
-    static readonly RULE_joinName = 129;
-    static readonly RULE_fieldName = 130;
-    static readonly RULE_justExpr = 131;
-    static readonly RULE_sqlExploreNameRef = 132;
-    static readonly RULE_nameSQLBlock = 133;
-    static readonly RULE_connectionName = 134;
-    static readonly RULE_experimentalStatementForTesting = 135;
+    static readonly RULE_caseStatement = 118;
+    static readonly RULE_caseWhen = 119;
+    static readonly RULE_recordKey = 120;
+    static readonly RULE_recordElement = 121;
+    static readonly RULE_argumentList = 122;
+    static readonly RULE_fieldNameList = 123;
+    static readonly RULE_fieldCollection = 124;
+    static readonly RULE_collectionWildCard = 125;
+    static readonly RULE_starQualified = 126;
+    static readonly RULE_taggedRef = 127;
+    static readonly RULE_refExpr = 128;
+    static readonly RULE_collectionMember = 129;
+    static readonly RULE_fieldPath = 130;
+    static readonly RULE_joinName = 131;
+    static readonly RULE_fieldName = 132;
+    static readonly RULE_justExpr = 133;
+    static readonly RULE_sqlExploreNameRef = 134;
+    static readonly RULE_nameSQLBlock = 135;
+    static readonly RULE_connectionName = 136;
+    static readonly RULE_experimentalStatementForTesting = 137;
     static readonly ruleNames: string[];
     private static readonly _LITERAL_NAMES;
     private static readonly _SYMBOLIC_NAMES;
@@ -430,6 +432,8 @@ export declare class MalloyParser extends Parser {
     partialAllowedFieldExpr(): PartialAllowedFieldExprContext;
     pickStatement(): PickStatementContext;
     pick(): PickContext;
+    caseStatement(): CaseStatementContext;
+    caseWhen(): CaseWhenContext;
     recordKey(): RecordKeyContext;
     recordElement(): RecordElementContext;
     argumentList(): ArgumentListContext;
@@ -2261,6 +2265,13 @@ export declare class ExprPickContext extends FieldExprContext {
     exitRule(listener: MalloyParserListener): void;
     accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
 }
+export declare class ExprCaseContext extends FieldExprContext {
+    caseStatement(): CaseStatementContext;
+    constructor(ctx: FieldExprContext);
+    enterRule(listener: MalloyParserListener): void;
+    exitRule(listener: MalloyParserListener): void;
+    accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
+}
 export declare class ExprUngroupContext extends FieldExprContext {
     ungroup(): UngroupContext;
     OPAREN(): TerminalNode;
@@ -2311,6 +2322,35 @@ export declare class PickContext extends ParserRuleContext {
     exitRule(listener: MalloyParserListener): void;
     accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
 }
+export declare class CaseStatementContext extends ParserRuleContext {
+    _valueExpr: FieldExprContext;
+    _caseElse: FieldExprContext;
+    CASE(): TerminalNode;
+    END(): TerminalNode;
+    caseWhen(): CaseWhenContext[];
+    caseWhen(i: number): CaseWhenContext;
+    ELSE(): TerminalNode | undefined;
+    fieldExpr(): FieldExprContext[];
+    fieldExpr(i: number): FieldExprContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyParserListener): void;
+    exitRule(listener: MalloyParserListener): void;
+    accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
+}
+export declare class CaseWhenContext extends ParserRuleContext {
+    _condition: FieldExprContext;
+    _result: FieldExprContext;
+    WHEN(): TerminalNode;
+    THEN(): TerminalNode;
+    fieldExpr(): FieldExprContext[];
+    fieldExpr(i: number): FieldExprContext;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyParserListener): void;
+    exitRule(listener: MalloyParserListener): void;
+    accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
+}
 export declare class RecordKeyContext extends ParserRuleContext {
     id(): IdContext;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);