@malloydata/malloy 0.0.198-dev241010185717 → 0.0.198-dev241011200222

package/dist/lang/ast/expressions/expr-alternation-tree.d.ts

@@ -1,14 +1,17 @@
 import { ExprValue } from '../types/expr-value';
 import { FieldSpace } from '../types/field-space';
-import { ExpressionDef } from '../types/expression-def';
+import { ATNodeType, ExpressionDef } from '../types/expression-def';
 import { BinaryMalloyOperator } from '../types/binary_operators';
 export declare class ExprAlternationTree extends ExpressionDef {
     readonly left: ExpressionDef;
     readonly op: '|' | '&';
     readonly right: ExpressionDef;
     elementType: string;
+    inList?: ExpressionDef[];
     constructor(left: ExpressionDef, op: '|' | '&', right: ExpressionDef);
-    apply(fs: FieldSpace, applyOp: BinaryMalloyOperator, expr: ExpressionDef): ExprValue;
+    equalityList(): ExpressionDef[];
+    apply(fs: FieldSpace, applyOp: BinaryMalloyOperator, expr: ExpressionDef, warnOnComplexTree: boolean): ExprValue;
     requestExpression(_fs: FieldSpace): ExprValue | undefined;
     getExpression(_fs: FieldSpace): ExprValue;
+    atNodeType(): ATNodeType;
 }

package/dist/lang/ast/expressions/expr-alternation-tree.js

@@ -25,6 +25,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprAlternationTree = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const expression_def_1 = require("../types/expression-def");
+const binary_operators_1 = require("../types/binary_operators");
+/**
+ * Return a flattened version of an alternation tree, if the tree is
+ * composed entirely values and "or"s.
+ *
+ * @param node Root of the tree
+ * @returns Undefined if other nodes are found in the tree
+ */
+function flattenOrTree(inNode) {
+    const node = inNode.atExpr();
+    switch (node.atNodeType()) {
+        case expression_def_1.ATNodeType.And:
+        case expression_def_1.ATNodeType.Partial:
+            return undefined;
+        case expression_def_1.ATNodeType.Or: {
+            if (node instanceof ExprAlternationTree) {
+                const left = flattenOrTree(node.left);
+                if (left) {
+                    const right = flattenOrTree(node.right);
+                    if (right) {
+                        return [...left, ...right];
+                    }
+                }
+            }
+            return undefined;
+        }
+        default:
+            return node.granular() ? undefined : [node];
+    }
+}
 class ExprAlternationTree extends expression_def_1.ExpressionDef {
     constructor(left, op, right) {
         super({ left, right });
@@ -34,7 +64,38 @@ class ExprAlternationTree extends expression_def_1.ExpressionDef {
         this.elementType = 'alternation';
         this.elementType = `${op}alternation${op}`;
     }
-    apply(fs, applyOp, expr) {
+    equalityList() {
+        if (this.inList === undefined) {
+            this.inList = flattenOrTree(this) || [];
+        }
+        return this.inList;
+    }
+    apply(fs, applyOp, expr, warnOnComplexTree) {
+        if ((0, binary_operators_1.isEquality)(applyOp)) {
+            const inList = this.equalityList();
+            if (inList.length > 0 && (applyOp === '=' || applyOp === '!=')) {
+                const isIn = expr.getExpression(fs);
+                const values = inList.map(v => v.getExpression(fs));
+                let { evalSpace, expressionType } = isIn;
+                for (const value of values) {
+                    evalSpace = (0, malloy_types_1.mergeEvalSpaces)(evalSpace, value.evalSpace);
+                    expressionType = (0, malloy_types_1.maxExpressionType)(expressionType, value.expressionType);
+                }
+                return {
+                    dataType: 'boolean',
+                    evalSpace,
+                    expressionType,
+                    value: {
+                        node: 'in',
+                        not: applyOp === '!=',
+                        kids: { e: isIn.value, oneOf: values.map(v => v.value) },
+                    },
+                };
+            }
+            if (inList.length === 0 && warnOnComplexTree) {
+                this.logWarning('or-choices-only', `Only | seperated values are legal when used with ${applyOp} operator`);
+            }
+        }
         const choice1 = this.left.apply(fs, applyOp, expr);
         const choice2 = this.right.apply(fs, applyOp, expr);
         return {
@@ -53,6 +114,9 @@ class ExprAlternationTree extends expression_def_1.ExpressionDef {
     getExpression(_fs) {
         return this.loggedErrorExpr('alternation-as-value', 'Alternation tree has no value');
     }
+    atNodeType() {
+        return this.op === '|' ? expression_def_1.ATNodeType.Or : expression_def_1.ATNodeType.And;
+    }
 }
 exports.ExprAlternationTree = ExprAlternationTree;
 //# sourceMappingURL=expr-alternation-tree.js.map

package/dist/lang/ast/expressions/expr-compare.d.ts

@@ -1,4 +1,4 @@
-import { CompareMalloyOperator } from '../types/binary_operators';
+import { BinaryMalloyOperator, CompareMalloyOperator, EqualityMalloyOperator } from '../types/binary_operators';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
@@ -8,3 +8,23 @@ export declare class ExprCompare extends BinaryBoolean<CompareMalloyOperator> {
     constructor(left: ExpressionDef, op: CompareMalloyOperator, right: ExpressionDef);
     getExpression(fs: FieldSpace): ExprValue;
 }
+/**
+ * The parser makes equality nodes, an application of ?
+ * makes an ExprCompare node with operator =. This is how
+ * the special rules for how apply works for equality
+ * nodes gets implemented.
+ */
+export declare class ExprEquality extends ExprCompare {
+    elementType: string;
+    constructor(left: ExpressionDef, op: EqualityMalloyOperator, right: ExpressionDef);
+    getExpression(fs: FieldSpace): ExprValue;
+    apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
+}
+export declare class ExprLegacyIn extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    readonly notIn: boolean;
+    readonly choices: ExpressionDef[];
+    elementType: string;
+    constructor(expr: ExpressionDef, notIn: boolean, choices: ExpressionDef[]);
+    getExpression(fs: FieldSpace): ExprValue;
+}

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

@@ -22,8 +22,10 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExprCompare = void 0;
+exports.ExprLegacyIn = exports.ExprEquality = exports.ExprCompare = void 0;
+const model_1 = require("../../../model");
 const fragtype_utils_1 = require("../fragtype-utils");
+const expression_def_1 = require("../types/expression-def");
 const binary_boolean_1 = require("./binary-boolean");
 const compareTypes = {
     '~': [fragtype_utils_1.FT.stringT],
@@ -46,4 +48,54 @@ class ExprCompare extends binary_boolean_1.BinaryBoolean {
     }
 }
 exports.ExprCompare = ExprCompare;
+/**
+ * The parser makes equality nodes, an application of ?
+ * makes an ExprCompare node with operator =. This is how
+ * the special rules for how apply works for equality
+ * nodes gets implemented.
+ */
+class ExprEquality extends ExprCompare {
+    constructor(left, op, right) {
+        super(left, op, right);
+        this.elementType = 'a~=b';
+    }
+    getExpression(fs) {
+        return this.right.apply(fs, this.op, this.left, true);
+    }
+    apply(fs, op, left) {
+        return super.apply(fs, op, left, true);
+    }
+}
+exports.ExprEquality = ExprEquality;
+class ExprLegacyIn extends expression_def_1.ExpressionDef {
+    constructor(expr, notIn, choices) {
+        super();
+        this.expr = expr;
+        this.notIn = notIn;
+        this.choices = choices;
+        this.elementType = 'in';
+        this.has({ expr, choices });
+    }
+    getExpression(fs) {
+        const lookFor = this.expr.getExpression(fs);
+        let { evalSpace, expressionType } = lookFor;
+        const oneOf = this.choices.map(e => {
+            const choice = e.getExpression(fs);
+            expressionType = (0, model_1.maxExpressionType)(expressionType, choice.expressionType);
+            evalSpace = (0, model_1.mergeEvalSpaces)(evalSpace, choice.evalSpace);
+            return choice.value;
+        });
+        return {
+            dataType: 'boolean',
+            expressionType,
+            evalSpace,
+            value: {
+                node: 'in',
+                not: this.notIn,
+                kids: { e: lookFor.value, oneOf },
+            },
+        };
+    }
+}
+exports.ExprLegacyIn = ExprLegacyIn;
 //# sourceMappingURL=expr-compare.js.map

package/dist/lang/ast/expressions/expr-parens.d.ts

@@ -1,5 +1,6 @@
+import { BinaryMalloyOperator } from '../types/binary_operators';
 import { ExprValue } from '../types/expr-value';
-import { ExpressionDef } from '../types/expression-def';
+import { ATNodeType, ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
 export declare class ExprParens extends ExpressionDef {
     readonly expr: ExpressionDef;
@@ -7,4 +8,7 @@ export declare class ExprParens extends ExpressionDef {
     constructor(expr: ExpressionDef);
     requestExpression(fs: FieldSpace): ExprValue | undefined;
     getExpression(fs: FieldSpace): ExprValue;
+    apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef, doWarn: boolean): ExprValue;
+    atNodeType(): ATNodeType;
+    atExpr(): ExpressionDef;
 }

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

@@ -37,6 +37,18 @@ class ExprParens extends expression_def_1.ExpressionDef {
         const subExpr = this.expr.getExpression(fs);
         return { ...subExpr, value: { node: '()', e: subExpr.value } };
     }
+    apply(fs, op, left, doWarn) {
+        if (this.expr.atNodeType() === expression_def_1.ATNodeType.Or) {
+            return this.expr.apply(fs, op, left, doWarn);
+        }
+        return (0, expression_def_1.applyBinary)(fs, left, op, this);
+    }
+    atNodeType() {
+        return this.expr.atNodeType();
+    }
+    atExpr() {
+        return this.expr;
+    }
 }
 exports.ExprParens = ExprParens;
 //# sourceMappingURL=expr-parens.js.map

package/dist/lang/ast/expressions/partial-compare.d.ts

@@ -1,6 +1,6 @@
 import { CompareMalloyOperator } from '../types/binary_operators';
 import { ExprValue } from '../types/expr-value';
-import { ExpressionDef } from '../types/expression-def';
+import { ATNodeType, ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
 export declare class PartialCompare extends ExpressionDef {
     readonly op: CompareMalloyOperator;
@@ -11,4 +11,5 @@ export declare class PartialCompare extends ExpressionDef {
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
     requestExpression(_fs: FieldSpace): ExprValue | undefined;
     getExpression(_fs: FieldSpace): ExprValue;
+    atNodeType(): ATNodeType;
 }

package/dist/lang/ast/expressions/partial-compare.js

@@ -43,6 +43,9 @@ class PartialCompare extends expression_def_1.ExpressionDef {
     getExpression(_fs) {
         return this.loggedErrorExpr('partial-as-value', 'Partial comparison does not have a value');
     }
+    atNodeType() {
+        return expression_def_1.ATNodeType.Partial;
+    }
 }
 exports.PartialCompare = PartialCompare;
 //# sourceMappingURL=partial-compare.js.map

package/dist/lang/ast/types/expression-def.d.ts

@@ -3,6 +3,13 @@ import { ExprValue } from './expr-value';
 import { FieldSpace } from './field-space';
 import { MalloyElement } from './malloy-element';
 import { BinaryMalloyOperator } from './binary_operators';
+/** Node types in an alternation tree */
+export declare enum ATNodeType {
+    And = 0,
+    Or = 1,
+    Value = 2,
+    Partial = 3
+}
 /**
  * Root node for any element in an expression. These essentially
  * create a sub-tree in the larger AST. Expression nodes know
@@ -45,11 +52,13 @@ export declare abstract class ExpressionDef extends MalloyElement {
      * @param expr The "other" (besdies 'this') value
      * @return The translated expression
      */
-    apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
+    apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef, _warnOnComplexTree?: boolean): ExprValue;
     canSupportPartitionBy(): boolean;
     canSupportOrderBy(): boolean;
     canSupportLimit(): boolean;
     supportsWhere(expr: ExprValue): boolean;
+    atNodeType(): ATNodeType;
+    atExpr(): ExpressionDef;
 }
 export declare class ExprDuration extends ExpressionDef {
     readonly n: ExpressionDef;

package/dist/lang/ast/types/expression-def.js

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyBinary = exports.getMorphicValue = exports.ExprDuration = exports.ExpressionDef = void 0;
+exports.applyBinary = exports.getMorphicValue = exports.ExprDuration = exports.ExpressionDef = exports.ATNodeType = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const ast_utils_1 = require("../ast-utils");
 const fragtype_utils_1 = require("../fragtype-utils");
@@ -32,6 +32,14 @@ const malloy_element_1 = require("./malloy-element");
 const binary_operators_1 = require("./binary_operators");
 class TypeMismatch extends Error {
 }
+/** Node types in an alternation tree */
+var ATNodeType;
+(function (ATNodeType) {
+    ATNodeType[ATNodeType["And"] = 0] = "And";
+    ATNodeType[ATNodeType["Or"] = 1] = "Or";
+    ATNodeType[ATNodeType["Value"] = 2] = "Value";
+    ATNodeType[ATNodeType["Partial"] = 3] = "Partial";
+})(ATNodeType || (exports.ATNodeType = ATNodeType = {}));
 /**
  * Root node for any element in an expression. These essentially
  * create a sub-tree in the larger AST. Expression nodes know
@@ -88,7 +96,7 @@ class ExpressionDef extends malloy_element_1.MalloyElement {
      * @param expr The "other" (besdies 'this') value
      * @return The translated expression
      */
-    apply(fs, op, left) {
+    apply(fs, op, left, _warnOnComplexTree = false) {
         return applyBinary(fs, left, op, this);
     }
     canSupportPartitionBy() {
@@ -103,6 +111,12 @@ class ExpressionDef extends malloy_element_1.MalloyElement {
     supportsWhere(expr) {
         return (0, malloy_types_1.expressionIsAggregate)(expr.expressionType);
     }
+    atNodeType() {
+        return ATNodeType.Value;
+    }
+    atExpr() {
+        return this;
+    }
 }
 exports.ExpressionDef = ExpressionDef;
 class ExprDuration extends ExpressionDef {

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

@@ -63,100 +63,101 @@ export declare class MalloyLexer extends Lexer {
     static readonly IMPORT = 58;
     static readonly INNER = 59;
     static readonly IS = 60;
-    static readonly JSON = 61;
-    static readonly LAST = 62;
-    static readonly LEFT = 63;
-    static readonly LIKE = 64;
-    static readonly MAX = 65;
-    static readonly MIN = 66;
-    static readonly MINUTE = 67;
-    static readonly MONTH = 68;
-    static readonly NOT = 69;
-    static readonly NOW = 70;
-    static readonly NULL = 71;
-    static readonly NUMBER = 72;
-    static readonly ON = 73;
-    static readonly OR = 74;
-    static readonly PICK = 75;
-    static readonly QUARTER = 76;
-    static readonly RIGHT = 77;
-    static readonly SECOND = 78;
-    static readonly STRING = 79;
-    static readonly SOURCE_KW = 80;
-    static readonly SUM = 81;
-    static readonly SQL = 82;
-    static readonly TABLE = 83;
-    static readonly THEN = 84;
-    static readonly THIS = 85;
-    static readonly TIMESTAMP = 86;
-    static readonly TO = 87;
-    static readonly TRUE = 88;
-    static readonly TURTLE = 89;
-    static readonly WEEK = 90;
-    static readonly WHEN = 91;
-    static readonly WITH = 92;
-    static readonly YEAR = 93;
-    static readonly UNGROUPED = 94;
-    static readonly STRING_ESCAPE = 95;
-    static readonly HACKY_REGEX = 96;
-    static readonly SQ_STRING = 97;
-    static readonly DQ_STRING = 98;
-    static readonly BQ_STRING = 99;
-    static readonly DOC_ANNOTATION = 100;
-    static readonly ANNOTATION = 101;
-    static readonly AMPER = 102;
-    static readonly ARROW = 103;
-    static readonly FAT_ARROW = 104;
-    static readonly OPAREN = 105;
-    static readonly CPAREN = 106;
-    static readonly OBRACK = 107;
-    static readonly CBRACK = 108;
-    static readonly OCURLY = 109;
-    static readonly CCURLY = 110;
-    static readonly DOUBLECOLON = 111;
-    static readonly TRIPLECOLON = 112;
-    static readonly EXCLAM = 113;
-    static readonly COLON = 114;
-    static readonly COMMA = 115;
-    static readonly DOT = 116;
-    static readonly LT = 117;
-    static readonly GT = 118;
-    static readonly EQ = 119;
-    static readonly NE = 120;
-    static readonly LTE = 121;
-    static readonly GTE = 122;
-    static readonly PLUS = 123;
-    static readonly MINUS = 124;
-    static readonly STAR = 125;
-    static readonly STARSTAR = 126;
-    static readonly SLASH = 127;
-    static readonly BAR = 128;
-    static readonly SEMI = 129;
-    static readonly NOT_MATCH = 130;
-    static readonly MATCH = 131;
-    static readonly PERCENT = 132;
-    static readonly DOUBLE_QMARK = 133;
-    static readonly QMARK = 134;
-    static readonly LITERAL_TIMESTAMP = 135;
-    static readonly LITERAL_HOUR = 136;
-    static readonly LITERAL_DAY = 137;
-    static readonly LITERAL_QUARTER = 138;
-    static readonly LITERAL_MONTH = 139;
-    static readonly LITERAL_WEEK = 140;
-    static readonly LITERAL_YEAR = 141;
-    static readonly IDENTIFIER = 142;
-    static readonly PERCENT_LITERAL = 143;
-    static readonly NUMERIC_LITERAL = 144;
-    static readonly INTEGER_LITERAL = 145;
-    static readonly BLOCK_COMMENT = 146;
-    static readonly COMMENT_TO_EOL = 147;
-    static readonly WHITE_SPACE = 148;
-    static readonly SQL_BEGIN = 149;
-    static readonly CLOSE_CODE = 150;
-    static readonly UNWATED_CHARS_TRAILING_NUMBERS = 151;
-    static readonly UNEXPECTED_CHAR = 152;
-    static readonly OPEN_CODE = 153;
-    static readonly SQL_END = 154;
+    static readonly IN = 61;
+    static readonly JSON = 62;
+    static readonly LAST = 63;
+    static readonly LEFT = 64;
+    static readonly LIKE = 65;
+    static readonly MAX = 66;
+    static readonly MIN = 67;
+    static readonly MINUTE = 68;
+    static readonly MONTH = 69;
+    static readonly NOT = 70;
+    static readonly NOW = 71;
+    static readonly NULL = 72;
+    static readonly NUMBER = 73;
+    static readonly ON = 74;
+    static readonly OR = 75;
+    static readonly PICK = 76;
+    static readonly QUARTER = 77;
+    static readonly RIGHT = 78;
+    static readonly SECOND = 79;
+    static readonly STRING = 80;
+    static readonly SOURCE_KW = 81;
+    static readonly SUM = 82;
+    static readonly SQL = 83;
+    static readonly TABLE = 84;
+    static readonly THEN = 85;
+    static readonly THIS = 86;
+    static readonly TIMESTAMP = 87;
+    static readonly TO = 88;
+    static readonly TRUE = 89;
+    static readonly TURTLE = 90;
+    static readonly WEEK = 91;
+    static readonly WHEN = 92;
+    static readonly WITH = 93;
+    static readonly YEAR = 94;
+    static readonly UNGROUPED = 95;
+    static readonly STRING_ESCAPE = 96;
+    static readonly HACKY_REGEX = 97;
+    static readonly SQ_STRING = 98;
+    static readonly DQ_STRING = 99;
+    static readonly BQ_STRING = 100;
+    static readonly DOC_ANNOTATION = 101;
+    static readonly ANNOTATION = 102;
+    static readonly AMPER = 103;
+    static readonly ARROW = 104;
+    static readonly FAT_ARROW = 105;
+    static readonly OPAREN = 106;
+    static readonly CPAREN = 107;
+    static readonly OBRACK = 108;
+    static readonly CBRACK = 109;
+    static readonly OCURLY = 110;
+    static readonly CCURLY = 111;
+    static readonly DOUBLECOLON = 112;
+    static readonly TRIPLECOLON = 113;
+    static readonly EXCLAM = 114;
+    static readonly COLON = 115;
+    static readonly COMMA = 116;
+    static readonly DOT = 117;
+    static readonly LT = 118;
+    static readonly GT = 119;
+    static readonly EQ = 120;
+    static readonly NE = 121;
+    static readonly LTE = 122;
+    static readonly GTE = 123;
+    static readonly PLUS = 124;
+    static readonly MINUS = 125;
+    static readonly STAR = 126;
+    static readonly STARSTAR = 127;
+    static readonly SLASH = 128;
+    static readonly BAR = 129;
+    static readonly SEMI = 130;
+    static readonly NOT_MATCH = 131;
+    static readonly MATCH = 132;
+    static readonly PERCENT = 133;
+    static readonly DOUBLE_QMARK = 134;
+    static readonly QMARK = 135;
+    static readonly LITERAL_TIMESTAMP = 136;
+    static readonly LITERAL_HOUR = 137;
+    static readonly LITERAL_DAY = 138;
+    static readonly LITERAL_QUARTER = 139;
+    static readonly LITERAL_MONTH = 140;
+    static readonly LITERAL_WEEK = 141;
+    static readonly LITERAL_YEAR = 142;
+    static readonly IDENTIFIER = 143;
+    static readonly PERCENT_LITERAL = 144;
+    static readonly NUMERIC_LITERAL = 145;
+    static readonly INTEGER_LITERAL = 146;
+    static readonly BLOCK_COMMENT = 147;
+    static readonly COMMENT_TO_EOL = 148;
+    static readonly WHITE_SPACE = 149;
+    static readonly SQL_BEGIN = 150;
+    static readonly CLOSE_CODE = 151;
+    static readonly UNWATED_CHARS_TRAILING_NUMBERS = 152;
+    static readonly UNEXPECTED_CHAR = 153;
+    static readonly OPEN_CODE = 154;
+    static readonly SQL_END = 155;
     static readonly SQL_MODE = 1;
     static readonly channelNames: string[];
     static readonly modeNames: string[];