@malloydata/malloy 0.0.225-dev250113200903 → 0.0.225-dev250113203344

package/dist/dialect/dialect.d.ts

@@ -62,9 +62,9 @@ export declare abstract class Dialect {
     supportsCountApprox: boolean;
     supportsHyperLogLog: boolean;
     supportsFullJoin: boolean;
-    nativeBoolean: boolean;
     nestedArrays: boolean;
     compoundObjectInSchema: boolean;
+    booleanAsNumbers: boolean;
     abstract getDialectFunctionOverrides(): {
         [name: string]: DialectFunctionOverloadDef[];
     };

package/dist/dialect/dialect.js

@@ -85,11 +85,12 @@ class Dialect {
         this.supportsHyperLogLog = false;
         // MYSQL doesn't have full join, maybe others.
         this.supportsFullJoin = true;
-        this.nativeBoolean = true;
         // Can have arrays of arrays
         this.nestedArrays = true;
         // An array or record will reveal type of contents on schema read
         this.compoundObjectInSchema = true;
+        // No true boolean type, e.g. true=1 and false=0, set this to true
+        this.booleanAsNumbers = false;
     }
     sqlFinalStage(_lastStageName, _fields) {
         throw new Error('Dialect has no final Stage but called Anyway');

package/dist/dialect/mysql/mysql.d.ts

@@ -22,13 +22,13 @@ export declare class MySQLDialect extends Dialect {
     supportsQualify: boolean;
     supportsNesting: boolean;
     experimental: boolean;
-    nativeBoolean: boolean;
     supportsFullJoin: boolean;
     supportsPipelinesInViews: boolean;
     readsNestedData: boolean;
     supportsComplexFilteredSources: boolean;
     supportsArraysInData: boolean;
     compoundObjectInSchema: boolean;
+    booleanAsNumbers: boolean;
     malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
     sqlTypeToMalloyType(sqlType: string): LeafAtomicTypeDef;
     quoteTablePath(tablePath: string): string;

package/dist/dialect/mysql/mysql.js

@@ -80,7 +80,7 @@ class MySQLDialect extends dialect_1.Dialect {
         this.defaultDecimalType = 'DECIMAL';
         this.udfPrefix = 'ms_temp.__udf';
         this.hasFinalStage = false;
-        // TODO: this may not be enough for lager casts.
+        // TODO: this may not be enough for larger casts.
         this.stringTypeName = 'VARCHAR(255)';
         this.divisionIsInteger = true;
         this.supportsSumDistinctFunction = true;
@@ -94,13 +94,13 @@ class MySQLDialect extends dialect_1.Dialect {
         this.supportsQualify = false;
         this.supportsNesting = true;
         this.experimental = false;
-        this.nativeBoolean = false;
         this.supportsFullJoin = false;
         this.supportsPipelinesInViews = false;
         this.readsNestedData = false;
         this.supportsComplexFilteredSources = false;
         this.supportsArraysInData = false;
         this.compoundObjectInSchema = false;
+        this.booleanAsNumbers = true;
     }
     malloyTypeToSQLType(malloyType) {
         switch (malloyType.type) {

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

@@ -55,7 +55,13 @@ class ExprNot extends unary_1.Unary {
         this.legalChildTypes = [TDU.boolT, TDU.nullT];
     }
     getExpression(fs) {
+        var _a;
         const notThis = this.expr.getExpression(fs);
+        if ((_a = fs.dialectObj()) === null || _a === void 0 ? void 0 : _a.booleanAsNumbers) {
+            if (this.legalChildTypes.find(t => t.type === 'number') === undefined) {
+                this.legalChildTypes.push(TDU.numberT);
+            }
+        }
         const doNot = this.typeCheck(this.expr, notThis);
         return {
             ...notThis,

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

@@ -1,6 +1,24 @@
+import { BinaryMalloyOperator, FieldSpace } from '..';
 import { ExprValue } from '../types/expr-value';
-import { ExpressionDef } from '../types/expression-def';
+import { ATNodeType, ExpressionDef } from '../types/expression-def';
 export declare class ExprNULL extends ExpressionDef {
     elementType: string;
     getExpression(): ExprValue;
+    apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
+}
+export declare class PartialIsNull extends ExpressionDef {
+    readonly op: '=' | '!=';
+    elementType: string;
+    constructor(op: '=' | '!=');
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
+    atNodeType(): ATNodeType;
+}
+export declare class ExprIsNull extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    readonly op: '=' | '!=';
+    elementType: string;
+    constructor(expr: ExpressionDef, op: '=' | '!=');
+    getExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -22,9 +22,18 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExprNULL = void 0;
+exports.ExprIsNull = exports.PartialIsNull = exports.ExprNULL = void 0;
 const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
+function doIsNull(fs, op, expr) {
+    const nullCmp = expr.getExpression(fs);
+    nullCmp.type = 'boolean';
+    nullCmp.value = {
+        node: op === '=' ? 'is-null' : 'is-not-null',
+        e: nullCmp.value,
+    };
+    return nullCmp;
+}
 class ExprNULL extends expression_def_1.ExpressionDef {
     constructor() {
         super(...arguments);
@@ -36,6 +45,45 @@ class ExprNULL extends expression_def_1.ExpressionDef {
             value: { node: 'null' },
         });
     }
+    apply(fs, op, left) {
+        if (op === '!=' || op === '=') {
+            return doIsNull(fs, op, left);
+        }
+        return super.apply(fs, op, left, true);
+    }
 }
 exports.ExprNULL = ExprNULL;
+class PartialIsNull extends expression_def_1.ExpressionDef {
+    constructor(op) {
+        super();
+        this.op = op;
+        this.elementType = '<=> NULL';
+    }
+    apply(fs, op, expr) {
+        return doIsNull(fs, this.op, expr);
+    }
+    requestExpression(_fs) {
+        return undefined;
+    }
+    getExpression(_fs) {
+        return this.loggedErrorExpr('partial-as-value', 'Partial null check does not have a value');
+    }
+    atNodeType() {
+        return expression_def_1.ATNodeType.Partial;
+    }
+}
+exports.PartialIsNull = PartialIsNull;
+class ExprIsNull extends expression_def_1.ExpressionDef {
+    constructor(expr, op) {
+        super();
+        this.expr = expr;
+        this.op = op;
+        this.elementType = 'is null';
+        this.has({ expr });
+    }
+    getExpression(fs) {
+        return doIsNull(fs, this.op, this.expr);
+    }
+}
+exports.ExprIsNull = ExprIsNull;
 //# sourceMappingURL=expr-null.js.map

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

@@ -251,22 +251,7 @@ function regexEqual(left, right) {
     }
     return undefined;
 }
-function nullCompare(left, op, right) {
-    const not = op === '!=' || op === '!~';
-    const nullCmp = not ? 'is-not-null' : 'is-null';
-    if (left.type === 'null' || right.type === 'null') {
-        if (left.type !== 'null') {
-            return { node: nullCmp, e: left.value };
-        }
-        if (right.type !== 'null') {
-            return { node: nullCmp, e: right.value };
-        }
-        return { node: not ? 'false' : 'true' };
-    }
-    return undefined;
-}
 function equality(fs, left, op, right) {
-    var _a;
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
     const node = (0, binary_operators_1.getExprNode)(op);
@@ -289,29 +274,20 @@ function equality(fs, left, op, right) {
         node,
         kids: { left: lhs.value, right: rhs.value },
     };
-    if (lhs.type !== 'error' && rhs.type !== 'error') {
-        switch (op) {
-            case '~':
-            case '!~': {
-                if (lhs.type !== 'string' || rhs.type !== 'string') {
-                    let regexCmp = regexEqual(lhs, rhs);
-                    if (regexCmp) {
-                        if (op[0] === '!') {
-                            regexCmp = { node: 'not', e: { ...regexCmp } };
-                        }
-                    }
-                    else {
-                        throw new TypeMismatch("Incompatible types for match('~') operator");
-                    }
-                    value = regexCmp;
+    if (lhs.type !== 'error' &&
+        rhs.type !== 'error' &&
+        (op === '~' || op === '!~')) {
+        if (lhs.type !== 'string' || rhs.type !== 'string') {
+            let regexCmp = regexEqual(lhs, rhs);
+            if (regexCmp) {
+                if (op[0] === '!') {
+                    regexCmp = { node: 'not', e: { ...regexCmp } };
                 }
-                break;
             }
-            case '=':
-            case '!=': {
-                value = (_a = nullCompare(lhs, op, rhs)) !== null && _a !== void 0 ? _a : value;
-                break;
+            else {
+                throw new TypeMismatch("Incompatible types for match('~') operator");
             }
+            value = regexCmp;
         }
     }
     return (0, expr_value_1.computedExprValue)({

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

@@ -296,32 +296,34 @@ export declare class MalloyParser extends Parser {
     static readonly RULE_ungroup = 121;
     static readonly RULE_malloyOrSQLType = 122;
     static readonly RULE_fieldExpr = 123;
-    static readonly RULE_partialAllowedFieldExpr = 124;
-    static readonly RULE_fieldExprList = 125;
-    static readonly RULE_pickStatement = 126;
-    static readonly RULE_pick = 127;
-    static readonly RULE_caseStatement = 128;
-    static readonly RULE_caseWhen = 129;
-    static readonly RULE_recordKey = 130;
-    static readonly RULE_recordElement = 131;
-    static readonly RULE_argumentList = 132;
-    static readonly RULE_fieldNameList = 133;
-    static readonly RULE_fieldCollection = 134;
-    static readonly RULE_collectionWildCard = 135;
-    static readonly RULE_starQualified = 136;
-    static readonly RULE_taggedRef = 137;
-    static readonly RULE_refExpr = 138;
-    static readonly RULE_collectionMember = 139;
-    static readonly RULE_fieldPath = 140;
-    static readonly RULE_joinName = 141;
-    static readonly RULE_fieldName = 142;
-    static readonly RULE_sqlExploreNameRef = 143;
-    static readonly RULE_nameSQLBlock = 144;
-    static readonly RULE_connectionName = 145;
-    static readonly RULE_debugExpr = 146;
-    static readonly RULE_debugPartial = 147;
-    static readonly RULE_experimentalStatementForTesting = 148;
-    static readonly RULE_closeCurly = 149;
+    static readonly RULE_partialCompare = 124;
+    static readonly RULE_partialTest = 125;
+    static readonly RULE_partialAllowedFieldExpr = 126;
+    static readonly RULE_fieldExprList = 127;
+    static readonly RULE_pickStatement = 128;
+    static readonly RULE_pick = 129;
+    static readonly RULE_caseStatement = 130;
+    static readonly RULE_caseWhen = 131;
+    static readonly RULE_recordKey = 132;
+    static readonly RULE_recordElement = 133;
+    static readonly RULE_argumentList = 134;
+    static readonly RULE_fieldNameList = 135;
+    static readonly RULE_fieldCollection = 136;
+    static readonly RULE_collectionWildCard = 137;
+    static readonly RULE_starQualified = 138;
+    static readonly RULE_taggedRef = 139;
+    static readonly RULE_refExpr = 140;
+    static readonly RULE_collectionMember = 141;
+    static readonly RULE_fieldPath = 142;
+    static readonly RULE_joinName = 143;
+    static readonly RULE_fieldName = 144;
+    static readonly RULE_sqlExploreNameRef = 145;
+    static readonly RULE_nameSQLBlock = 146;
+    static readonly RULE_connectionName = 147;
+    static readonly RULE_debugExpr = 148;
+    static readonly RULE_debugPartial = 149;
+    static readonly RULE_experimentalStatementForTesting = 150;
+    static readonly RULE_closeCurly = 151;
     static readonly ruleNames: string[];
     private static readonly _LITERAL_NAMES;
     private static readonly _SYMBOLIC_NAMES;
@@ -459,6 +461,8 @@ export declare class MalloyParser extends Parser {
     malloyOrSQLType(): MalloyOrSQLTypeContext;
     fieldExpr(): FieldExprContext;
     fieldExpr(_p: number): FieldExprContext;
+    partialCompare(): PartialCompareContext;
+    partialTest(): PartialTestContext;
     partialAllowedFieldExpr(): PartialAllowedFieldExprContext;
     fieldExprList(): FieldExprListContext;
     pickStatement(): PickStatementContext;
@@ -2330,7 +2334,7 @@ export declare class ExprWarnLikeContext extends FieldExprContext {
     exitRule(listener: MalloyParserListener): void;
     accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
 }
-export declare class ExprWarnNullCmpContext extends FieldExprContext {
+export declare class ExprNullCheckContext extends FieldExprContext {
     fieldExpr(): FieldExprContext;
     IS(): TerminalNode;
     NULL(): TerminalNode;
@@ -2483,11 +2487,31 @@ export declare class ExprUngroupContext extends FieldExprContext {
     exitRule(listener: MalloyParserListener): void;
     accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
 }
+export declare class PartialCompareContext extends ParserRuleContext {
+    compareOp(): CompareOpContext;
+    fieldExpr(): 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 PartialTestContext extends ParserRuleContext {
+    partialCompare(): PartialCompareContext | undefined;
+    IS(): TerminalNode | undefined;
+    NULL(): TerminalNode | undefined;
+    NOT(): TerminalNode | undefined;
+    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 PartialAllowedFieldExprContext extends ParserRuleContext {
+    partialTest(): PartialTestContext | undefined;
     OPAREN(): TerminalNode | undefined;
-    fieldExpr(): FieldExprContext;
     CPAREN(): TerminalNode | undefined;
-    compareOp(): CompareOpContext | undefined;
+    fieldExpr(): FieldExprContext | undefined;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: MalloyParserListener): void;