@malloydata/malloy 0.0.197 → 0.0.198-dev241010181909

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

@@ -50,6 +50,7 @@ import { ExprExprContext } from "./MalloyParser";
 import { ExprAggFuncContext } from "./MalloyParser";
 import { ExprFuncContext } from "./MalloyParser";
 import { ExprPickContext } from "./MalloyParser";
+import { ExprCaseContext } from "./MalloyParser";
 import { ExprUngroupContext } from "./MalloyParser";
 import { SegFieldContext } from "./MalloyParser";
 import { SegOpsContext } from "./MalloyParser";
@@ -197,6 +198,8 @@ import { FieldExprContext } from "./MalloyParser";
 import { PartialAllowedFieldExprContext } from "./MalloyParser";
 import { PickStatementContext } from "./MalloyParser";
 import { PickContext } from "./MalloyParser";
+import { CaseStatementContext } from "./MalloyParser";
+import { CaseWhenContext } from "./MalloyParser";
 import { RecordKeyContext } from "./MalloyParser";
 import { RecordElementContext } from "./MalloyParser";
 import { ArgumentListContext } from "./MalloyParser";
@@ -832,6 +835,18 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitExprPick?: (ctx: ExprPickContext) => void;
+    /**
+     * Enter a parse tree produced by the `exprCase`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     */
+    enterExprCase?: (ctx: ExprCaseContext) => void;
+    /**
+     * Exit a parse tree produced by the `exprCase`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     */
+    exitExprCase?: (ctx: ExprCaseContext) => void;
     /**
      * Enter a parse tree produced by the `exprUngroup`
      * labeled alternative in `MalloyParser.fieldExpr`.
@@ -2360,6 +2375,26 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitPick?: (ctx: PickContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.caseStatement`.
+     * @param ctx the parse tree
+     */
+    enterCaseStatement?: (ctx: CaseStatementContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.caseStatement`.
+     * @param ctx the parse tree
+     */
+    exitCaseStatement?: (ctx: CaseStatementContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.caseWhen`.
+     * @param ctx the parse tree
+     */
+    enterCaseWhen?: (ctx: CaseWhenContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.caseWhen`.
+     * @param ctx the parse tree
+     */
+    exitCaseWhen?: (ctx: CaseWhenContext) => void;
     /**
      * Enter a parse tree produced by `MalloyParser.recordKey`.
      * @param ctx the parse tree

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

@@ -50,6 +50,7 @@ import { ExprExprContext } from "./MalloyParser";
 import { ExprAggFuncContext } from "./MalloyParser";
 import { ExprFuncContext } from "./MalloyParser";
 import { ExprPickContext } from "./MalloyParser";
+import { ExprCaseContext } from "./MalloyParser";
 import { ExprUngroupContext } from "./MalloyParser";
 import { SegFieldContext } from "./MalloyParser";
 import { SegOpsContext } from "./MalloyParser";
@@ -197,6 +198,8 @@ import { FieldExprContext } from "./MalloyParser";
 import { PartialAllowedFieldExprContext } from "./MalloyParser";
 import { PickStatementContext } from "./MalloyParser";
 import { PickContext } from "./MalloyParser";
+import { CaseStatementContext } from "./MalloyParser";
+import { CaseWhenContext } from "./MalloyParser";
 import { RecordKeyContext } from "./MalloyParser";
 import { RecordElementContext } from "./MalloyParser";
 import { ArgumentListContext } from "./MalloyParser";
@@ -580,6 +583,13 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitExprPick?: (ctx: ExprPickContext) => Result;
+    /**
+     * Visit a parse tree produced by the `exprCase`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExprCase?: (ctx: ExprCaseContext) => Result;
     /**
      * Visit a parse tree produced by the `exprUngroup`
      * labeled alternative in `MalloyParser.fieldExpr`.
@@ -1491,6 +1501,18 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitPick?: (ctx: PickContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.caseStatement`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitCaseStatement?: (ctx: CaseStatementContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.caseWhen`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitCaseWhen?: (ctx: CaseWhenContext) => Result;
     /**
      * Visit a parse tree produced by `MalloyParser.recordKey`.
      * @param ctx the parse tree

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

@@ -45,6 +45,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
      */
     protected astError<T extends MessageCode>(el: ast.MalloyElement, code: T, data: MessageParameterType<T>, options?: LogMessageOptions): void;
     protected getLocation(cx: ParserRuleContext): DocumentLocation;
+    protected getSourceString(cx: ParserRuleContext): string;
     /**
      * Log an error message relative to a parse node
      */
@@ -187,6 +188,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitExprAggFunc(pcx: parse.ExprAggFuncContext): ast.ExpressionDef;
     visitExprFunc(pcx: parse.ExprFuncContext): ast.ExpressionDef;
     visitExprDuration(pcx: parse.ExprDurationContext): ast.ExprDuration;
+    visitCaseStatement(pcx: parse.CaseStatementContext): ast.Case;
     visitPickStatement(pcx: parse.PickStatementContext): ast.Pick;
     visitExprFieldProps(pcx: parse.ExprFieldPropsContext): ast.ExprProps;
     visitPartitionByStatement(pcx: parse.PartitionByStatementContext): ast.PartitionBy;

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

@@ -110,6 +110,9 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
             range: this.parseInfo.rangeFromContext(cx),
         };
     }
+    getSourceString(cx) {
+        return this.parseInfo.sourceStream.getText(new Interval_1.Interval(cx.start.startIndex, cx.stop ? cx.stop.stopIndex : cx.start.startIndex));
+    }
     /**
      * Log an error message relative to a parse node
      */
@@ -1116,6 +1119,22 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     visitExprDuration(pcx) {
         return new ast.ExprDuration(this.getFieldExpr(pcx.fieldExpr()), this.visitTimeframe(pcx.timeframe()).text);
     }
+    visitCaseStatement(pcx) {
+        const valueCx = pcx._valueExpr;
+        const value = valueCx ? this.getFieldExpr(valueCx) : undefined;
+        const whenCxs = pcx.caseWhen();
+        const whens = whenCxs.map(whenCx => {
+            return new ast.CaseWhen(this.getFieldExpr(whenCx._condition), this.getFieldExpr(whenCx._result));
+        });
+        const elseCx = pcx._caseElse;
+        const theElse = elseCx ? this.getFieldExpr(elseCx) : undefined;
+        this.warnWithReplacement('sql-case', 'Use a `pick` statement instead of `case`', this.parseInfo.rangeFromContext(pcx), `${[
+            ...(valueCx ? [`${this.getSourceCode(valueCx)} ?`] : []),
+            ...whenCxs.map(whenCx => `pick ${this.getSourceCode(whenCx._result)} when ${this.getSourceCode(whenCx._condition)}`),
+            elseCx ? `else ${elseCx.text}` : 'else null',
+        ].join(' ')}`);
+        return new ast.Case(value, whens, theElse);
+    }
     visitPickStatement(pcx) {
         const picks = pcx.pick().map(pwCx => {
             let pickExpr;
@@ -1347,10 +1366,10 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const wholeRange = this.parseInfo.rangeFromContext(pcx);
         if (pcx.NOT()) {
             op = '!~';
-            this.warnWithReplacement('sql-not-like', "Use Malloy operator '!~' instead of 'NOT LIKE'", wholeRange, `${left.text} !~ ${right.text}`);
+            this.warnWithReplacement('sql-not-like', "Use Malloy operator '!~' instead of 'NOT LIKE'", wholeRange, `${this.getSourceCode(left)} !~ ${this.getSourceCode(right)}`);
         }
         else {
-            this.warnWithReplacement('sql-like', "Use Malloy operator '~' instead of 'LIKE'", wholeRange, `${left.text} ~ ${right.text}`);
+            this.warnWithReplacement('sql-like', "Use Malloy operator '~' instead of 'LIKE'", wholeRange, `${this.getSourceCode(left)} ~ ${this.getSourceCode(right)}`);
         }
         return this.astAt(new ast.ExprCompare(this.getFieldExpr(left), op, this.getFieldExpr(right)), pcx);
     }
@@ -1360,10 +1379,10 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const wholeRange = this.parseInfo.rangeFromContext(pcx);
         if (pcx.NOT()) {
             op = '!=';
-            this.warnWithReplacement('sql-is-not-null', "Use '!= NULL' to check for NULL instead of 'IS NOT NULL'", wholeRange, `${expr.text} != null`);
+            this.warnWithReplacement('sql-is-not-null', "Use '!= NULL' to check for NULL instead of 'IS NOT NULL'", wholeRange, `${this.getSourceCode(expr)} != null`);
         }
         else {
-            this.warnWithReplacement('sql-is-null', "Use '= NULL' to check for NULL instead of 'IS NULL'", wholeRange, `${expr.text} = null`);
+            this.warnWithReplacement('sql-is-null', "Use '= NULL' to check for NULL instead of 'IS NULL'", wholeRange, `${this.getSourceCode(expr)} = null`);
         }
         const nullExpr = new ast.ExprNULL();
         return this.astAt(new ast.ExprCompare(this.getFieldExpr(expr), op, nullExpr), pcx);

package/dist/lang/parse-log.d.ts

@@ -52,7 +52,7 @@ type MessageParameterTypes = {
     'pick-missing-value': {};
     'pick-illegal-partial': {};
     'pick-when-must-be-boolean': {
-        whenType: string;
+        whenType: FieldValueType;
     };
     'experiment-not-enabled': {
         experimentId: string;
@@ -315,6 +315,22 @@ type MessageParameterTypes = {
     'sql-is-not-null': string;
     'sql-is-null': string;
     'illegal-record-property-type': string;
+    'sql-case': string;
+    'case-then-type-does-not-match': {
+        thenType: FieldValueType;
+        returnType: FieldValueType;
+    };
+    'case-else-type-does-not-match': {
+        elseType: FieldValueType;
+        returnType: FieldValueType;
+    };
+    'case-when-must-be-boolean': {
+        whenType: FieldValueType;
+    };
+    'case-when-type-does-not-match': {
+        whenType: FieldValueType;
+        valueType: FieldValueType;
+    };
     'dialect-cast-unsafe-only': string;
 };
 export declare const MESSAGE_FORMATTERS: PartialErrorCodeMessageMap;

package/dist/lang/parse-log.js

@@ -90,6 +90,10 @@ exports.MESSAGE_FORMATTERS = {
     'syntax-error': e => e.message,
     'internal-translator-error': e => `Internal Translator Error: ${e.message}`,
     'invalid-timezone': e => `Invalid timezone: ${e.timezone}`,
+    'case-then-type-does-not-match': e => `Case then type ${e.thenType} does not match return type ${e.returnType}`,
+    'case-else-type-does-not-match': e => `Case else type ${e.elseType} does not match return type ${e.returnType}`,
+    'case-when-must-be-boolean': e => `Case when expression must be boolean, not ${e.whenType}`,
+    'case-when-type-does-not-match': e => `Case when type ${e.whenType} does not match value type ${e.valueType}`,
 };
 function makeLogMessage(code, parameters, options) {
     var _a, _b, _c, _d, _e;

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

@@ -735,6 +735,172 @@ describe('expressions', () => {
       }`).toLog((0, test_translator_1.errorMessage)("'output' is not defined"));
         });
     });
+    describe('case statements', () => {
+        test('full', () => {
+            const e = (0, test_translator_1.expr) `
+        case
+          when ai = 42 then 'the answer'
+          when ai = 54 then 'the questionable answer'
+          else 'random'
+        end
+      `;
+            expect(e).toLog((0, test_translator_1.warning)('sql-case'));
+            expect(e).compilesTo('{case when {ai = 42} then "the answer" when {ai = 54} then "the questionable answer" else "random"}');
+        });
+        test('with value', () => {
+            const e = (0, test_translator_1.expr) `
+        case ai
+          when 42 then 'the answer'
+          when 54 then 'the questionable answer'
+          else 'random'
+        end
+      `;
+            expect(e).toLog((0, test_translator_1.warning)('sql-case'));
+            expect(e).compilesTo('{case ai when 42 then "the answer" when 54 then "the questionable answer" else "random"}');
+        });
+        test('no else', () => {
+            const e = (0, test_translator_1.expr) `
+        case
+          when ai = 42 then 'the answer'
+          when ai = 54 then 'the questionable answer'
+        end
+      `;
+            expect(e).toLog((0, test_translator_1.warning)('sql-case'));
+            expect(e).compilesTo('{case when {ai = 42} then "the answer" when {ai = 54} then "the questionable answer"}');
+        });
+        test('wrong then type', () => {
+            expect((0, test_translator_1.expr) `
+        case
+          when ai = 42 then 'the answer'
+          when ai = 54 then 7
+        end
+      `).toLog((0, test_translator_1.warning)('sql-case'), (0, test_translator_1.error)('case-then-type-does-not-match', {
+                thenType: 'number',
+                returnType: 'string',
+            }));
+        });
+        test('wrong when type', () => {
+            expect((0, test_translator_1.expr) `
+        case ai
+          when 42 then 'the answer'
+          when 'forty-two' then 'the answer but string'
+        end
+      `).toLog((0, test_translator_1.warning)('sql-case'), (0, test_translator_1.error)('case-when-type-does-not-match', {
+                whenType: 'string',
+                valueType: 'number',
+            }));
+        });
+        test('wrong else type', () => {
+            expect((0, test_translator_1.expr) `
+        case
+          when ai = 42 then 'the answer'
+          else @2020
+        end
+      `).toLog((0, test_translator_1.warning)('sql-case'), (0, test_translator_1.error)('case-else-type-does-not-match', {
+                elseType: 'date',
+                returnType: 'string',
+            }));
+        });
+        test('null then type okay second', () => {
+            expect((0, test_translator_1.expr) `
+        case
+          when ai = 42 then 'the answer'
+          when ai = 54 then null
+        end
+      `).toLog((0, test_translator_1.warning)('sql-case'));
+        });
+        test('null then type okay first', () => {
+            expect((0, test_translator_1.expr) `
+        case
+          when ai = 54 then null
+          when ai = 42 then 'the answer'
+        end
+      `).toLog((0, test_translator_1.warning)('sql-case'));
+        });
+        test('null else type okay', () => {
+            expect((0, test_translator_1.expr) `
+        case
+          when ai = 42 then 'the answer'
+          else null
+        end
+      `).toLog((0, test_translator_1.warning)('sql-case'));
+        });
+        test('null then type before else okay', () => {
+            expect((0, test_translator_1.expr) `
+        case
+          when ai = 42 then null
+          else 'not the answer'
+        end
+      `).toLog((0, test_translator_1.warning)('sql-case'));
+        });
+        test('non boolean when', () => {
+            expect((0, test_translator_1.expr) `
+        case when ai then null end
+      `).toLog((0, test_translator_1.warning)('sql-case'), (0, test_translator_1.error)('case-when-must-be-boolean'));
+        });
+        test('type of null then second', () => {
+            expect(`
+        case
+          when ai = 42 then 'the answer'
+          when ai = 54 then null
+        end
+      `).toReturnType('string');
+        });
+        test('type of null then first', () => {
+            expect(`
+        case
+          when ai = 54 then null
+          when ai = 42 then 'the answer'
+        end
+      `).toReturnType('string');
+        });
+        test('type of null else', () => {
+            expect(`
+        case
+          when ai = 42 then 'the answer'
+          else null
+        end
+      `).toReturnType('string');
+        });
+        test('type of null then type before else', () => {
+            expect(`
+        case
+          when ai = 42 then null
+          else 'not the answer'
+        end
+      `).toReturnType('string');
+        });
+        test('replacement for full case', () => {
+            const e = (0, test_translator_1.expr) `case
+        when ai = 42 then 'the answer'
+        when ai = 54 then 'the questionable answer'
+        else 'random'
+      end`;
+            e.translator.translate();
+            expect(e.translator.logger.getLog()[0].replacement).toBe("pick 'the answer' when ai = 42 pick 'the questionable answer' when ai = 54 else 'random'");
+        });
+        test('replacement for case with no else', () => {
+            const e = (0, test_translator_1.expr) `case
+        when ai = 42 then 'the answer'
+        when ai = 54 then 'the questionable answer'
+      end`;
+            e.translator.translate();
+            expect(e.translator.logger.getLog()[0].replacement).toBe("pick 'the answer' when ai = 42 pick 'the questionable answer' when ai = 54 else null");
+        });
+        test('replacement for case with value', () => {
+            const e = (0, test_translator_1.expr) `case ai
+        when 42 then 'a'
+        when 54 then 'b'
+      end`;
+            e.translator.translate();
+            expect(e.translator.logger.getLog()[0].replacement).toBe("ai ? pick 'a' when 42 pick 'b' when 54 else null");
+        });
+        test('interaction with pick', () => {
+            expect((0, test_translator_1.expr) `
+        pick case when true then 'hooray' end when true else null
+      `).toLog((0, test_translator_1.warning)('sql-case'));
+        });
+    });
     describe('pick statements', () => {
         test('full', () => {
             expect((0, test_translator_1.expr) `

package/dist/lang/test/parse-expects.js

@@ -33,11 +33,11 @@ function rangeToStr(loc) {
     }
     return 'undefined';
 }
-function ensureNoProblems(trans) {
+function ensureNoProblems(trans, warningsOkay = false) {
     if (trans.logger === undefined) {
         throw new Error('JESTERY BROKEN, CANT FIND ERORR LOG');
     }
-    if (!trans.logger.empty()) {
+    if (warningsOkay ? trans.logger.hasErrors() : !trans.logger.empty()) {
         return {
             message: () => `Translation problems:\n${trans.prettyErrors()}`,
             pass: false,
@@ -114,8 +114,8 @@ function xlator(ts) {
     }
     return ts.translator || new test_translator_1.TestTranslator(ts.code);
 }
-function xlated(tt) {
-    const errorCheck = ensureNoProblems(tt);
+function xlated(tt, warningsOkay = false) {
+    const errorCheck = ensureNoProblems(tt, warningsOkay);
     if (!errorCheck.pass) {
         return errorCheck;
     }
@@ -157,6 +157,19 @@ function eToStr(e, symbols) {
         case 'true':
         case 'false':
             return e.node;
+        case 'case': {
+            const caseStmt = ['case'];
+            if (e.kids.caseValue !== undefined) {
+                caseStmt.push(`${subExpr(e.kids.caseValue)}`);
+            }
+            for (let i = 0; i < e.kids.caseWhen.length; i += 1) {
+                caseStmt.push(`when ${subExpr(e.kids.caseWhen[i])} then ${subExpr(e.kids.caseThen[i])}`);
+            }
+            if (e.kids.caseElse !== undefined) {
+                caseStmt.push(`else ${subExpr(e.kids.caseElse)}`);
+            }
+            return `{${caseStmt.join(' ')}}`;
+        }
         case 'regexpMatch':
             return `{${subExpr(e.kids.expr)} regex-match ${subExpr(e.kids.regex)}}`;
     }
@@ -185,13 +198,13 @@ expect.extend({
     toReturnType: function (exprText, returnType) {
         const exprModel = new test_translator_1.BetaExpression(exprText);
         exprModel.compile();
-        const ok = xlated(exprModel);
+        const ok = xlated(exprModel, true);
         if (!ok.pass) {
             return ok;
         }
         const d = exprModel.generated();
         const pass = d.dataType === returnType;
-        const msg = `Expression type ${d.dataType} ${pass ? '=' : '!='} $[returnType`;
+        const msg = `Expression type ${d.dataType} ${pass ? '=' : '!='} ${returnType}`;
         return { pass, message: () => msg };
     },
     toLog: function (s, ...msgs) {

package/dist/model/malloy_query.d.ts

@@ -1,5 +1,5 @@
 import { Dialect, DialectFieldList } from '../dialect';
-import { AggregateFunctionType, Annotation, CompiledQuery, Expr, FieldDef, Filtered, FunctionOverloadDef, FunctionParameterDef, JoinRelationship, ModelDef, OrderBy, OutputFieldNode, Parameter, ParameterNode, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SegmentFieldDef, StructDef, StructRef, TurtleDef, FunctionOrderBy, Argument, AggregateExpr, FilterCondition, GenericSQLExpr, FieldnameNode, FunctionCallNode, UngroupNode, SourceReferenceNode, PickExpr, SpreadExpr, FilteredExpr, SourceDef, AtomicFieldDef, BooleanFieldDef, QueryToMaterialize, PrepareResultOptions } from './malloy_types';
+import { AggregateFunctionType, Annotation, CompiledQuery, Expr, FieldDef, Filtered, FunctionOverloadDef, FunctionParameterDef, JoinRelationship, ModelDef, OrderBy, OutputFieldNode, Parameter, ParameterNode, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SegmentFieldDef, StructDef, StructRef, TurtleDef, FunctionOrderBy, Argument, AggregateExpr, FilterCondition, GenericSQLExpr, FieldnameNode, FunctionCallNode, UngroupNode, SourceReferenceNode, SpreadExpr, FilteredExpr, SourceDef, AtomicFieldDef, BooleanFieldDef, QueryToMaterialize, PrepareResultOptions, CaseExpr } from './malloy_types';
 import { Connection } from '../connection/types';
 import { AndChain } from './utils';
 import { QueryInfo } from '../dialect/dialect';
@@ -92,7 +92,7 @@ declare class QueryField extends QueryNode {
     generateSourceReference(resultSet: FieldInstanceResult, context: QueryStruct, expr: SourceReferenceNode): string;
     getAnalyticPartitions(resultStruct: FieldInstanceResult, extraPartitionFields?: string[]): string[];
     generateAnalyticFragment(dialect: string, resultStruct: FieldInstanceResult, context: QueryStruct, expr: Expr, overload: FunctionOverloadDef, state: GenerateState, args: Expr[], partitionByFields?: string[], funcOrdering?: string): string;
-    generatePickSQL(pf: PickExpr): string;
+    generateCaseSQL(pf: CaseExpr): string;
     exprToSQL(resultSet: FieldInstanceResult, context: QueryStruct, exprToTranslate: Expr, state?: GenerateState): string;
     isNestedInParent(parentDef: FieldDef): boolean;
     isArrayElement(parentDef: FieldDef): boolean;

package/dist/model/malloy_query.js

@@ -708,12 +708,18 @@ class QueryField extends QueryNode {
         }
         return retExpr;
     }
-    generatePickSQL(pf) {
+    generateCaseSQL(pf) {
         const caseStmt = ['CASE'];
-        for (let i = 0; i < pf.kids.pickWhen.length; i += 1) {
-            caseStmt.push(`WHEN ${pf.kids.pickWhen[i].sql} THEN ${pf.kids.pickThen[i].sql}`);
+        if (pf.kids.caseValue !== undefined) {
+            caseStmt.push(`${pf.kids.caseValue.sql}`);
         }
-        caseStmt.push(`ELSE ${pf.kids.pickElse.sql}`, 'END');
+        for (let i = 0; i < pf.kids.caseWhen.length; i += 1) {
+            caseStmt.push(`WHEN ${pf.kids.caseWhen[i].sql} THEN ${pf.kids.caseThen[i].sql}`);
+        }
+        if (pf.kids.caseElse !== undefined) {
+            caseStmt.push(`ELSE ${pf.kids.caseElse.sql}`);
+        }
+        caseStmt.push('END');
         return caseStmt.join(' ');
     }
     exprToSQL(resultSet, context, exprToTranslate, state = new GenerateState()) {
@@ -740,6 +746,8 @@ class QueryField extends QueryNode {
             expr = { ...exprToTranslate };
             const oldKids = exprToTranslate.kids;
             for (const [name, kidExpr] of Object.entries(oldKids)) {
+                if (kidExpr === null)
+                    continue;
                 if (Array.isArray(kidExpr)) {
                     expr.kids[name] = kidExpr.map(e => {
                         return { ...e, sql: subExpr(this, e) };
@@ -852,8 +860,8 @@ class QueryField extends QueryNode {
                 return expr.node;
             case 'null':
                 return 'NULL';
-            case 'pick':
-                return this.generatePickSQL(expr);
+            case 'case':
+                return this.generateCaseSQL(expr);
             case '':
                 return '';
             case 'filterCondition':

package/dist/model/malloy_types.d.ts

@@ -24,7 +24,7 @@ export type AnyExpr = ExprE | ExprOptionalE | ExprWithKids | ExprLeaf;
 export declare function exprHasKids(e: AnyExpr): e is ExprWithKids;
 export declare function exprHasE(e: AnyExpr): e is ExprE;
 export declare function exprIsLeaf(e: AnyExpr): boolean;
-export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | NowNode | MeasureTimeExpr | TimeDeltaExpr | TimeTruncExpr | TimeExtractExpr | TypecastExpr | RegexMatchExpr | RegexLiteralNode | TimeLiteralNode | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | RecordLiteralNode | ArrayLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | PickExpr | ArrayEachExpr | ErrorNode;
+export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | NowNode | MeasureTimeExpr | TimeDeltaExpr | TimeTruncExpr | TimeExtractExpr | TypecastExpr | RegexMatchExpr | RegexLiteralNode | TimeLiteralNode | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | RecordLiteralNode | ArrayLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | CaseExpr | ArrayEachExpr | ErrorNode;
 interface HasDataType {
     dataType: AtomicFieldType;
 }
@@ -210,12 +210,13 @@ export interface GenericSQLExpr extends ExprWithKids {
 export interface NullNode extends ExprLeaf {
     node: 'null';
 }
-export interface PickExpr extends ExprWithKids {
-    node: 'pick';
+export interface CaseExpr extends ExprWithKids {
+    node: 'case';
     kids: {
-        pickWhen: Expr[];
-        pickThen: Expr[];
-        pickElse: Expr;
+        caseValue?: Expr;
+        caseWhen: Expr[];
+        caseThen: Expr[];
+        caseElse?: Expr;
     };
 }
 export interface ArrayEachExpr extends ExprLeaf {

package/dist/model/utils.js

@@ -119,7 +119,7 @@ function* exprKids(eNode) {
             if (Array.isArray(kidEnt)) {
                 yield* kidEnt;
             }
-            else {
+            else if (kidEnt !== null) {
                 yield kidEnt;
             }
         }
@@ -150,7 +150,7 @@ function exprMap(eNode, mapFunc) {
             if (Array.isArray(kidEnt)) {
                 parentNode.kids[name] = kidEnt.map(kidEl => mapFunc(kidEl));
             }
-            else {
+            else if (kidEnt !== null) {
                 parentNode.kids[name] = mapFunc(kidEnt);
             }
         }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.197";
+export declare const MALLOY_VERSION = "0.0.198";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.197';
+exports.MALLOY_VERSION = '0.0.198';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.197",
+  "version": "0.0.198-dev241010181909",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",