@malloydata/malloy 0.0.225-dev250111002123 → 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/statements/import-statement.js

@@ -82,8 +82,9 @@ class ImportStatement extends malloy_element_1.ListOf {
             this.logError('no-translator-for-import', 'Cannot import without translation context');
         }
         else if (this.fullURL) {
+            const pretranslated = trans.root.pretranslatedModels.get(this.fullURL);
             const src = trans.root.importZone.getEntry(this.fullURL);
-            if (src.status === 'present') {
+            if (pretranslated || src.status === 'present') {
                 const importable = trans.getChildExports(this.fullURL);
                 if (this.notEmpty()) {
                     // just import the named objects

package/dist/lang/ast/types/document-compile-result.d.ts

@@ -1,8 +1,6 @@
-import { ModelDef, Query, SQLSourceDef } from '../../../model/malloy_types';
+import { ModelDef } from '../../../model/malloy_types';
 import { ModelDataRequest } from '../../translate-response';
 export interface DocumentCompileResult {
     modelDef: ModelDef;
-    queryList: Query[];
-    sqlBlocks: SQLSourceDef[];
     needs: ModelDataRequest;
 }

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/ast/types/malloy-element.d.ts

@@ -1,4 +1,4 @@
-import { Annotation, DocumentLocation, DocumentReference, ModelDef, ModelAnnotation, NamedModelObject, Query, SQLSourceDef, StructDef } from '../../../model/malloy_types';
+import { Annotation, DocumentLocation, DocumentReference, ModelDef, ModelAnnotation, NamedModelObject, Query, StructDef } from '../../../model/malloy_types';
 import { Tag } from '../../../tags';
 import { LogMessageOptions, MessageLogger, MessageParameterType, MessageCode } from '../../parse-log';
 import { MalloyTranslation } from '../../parse-malloy';
@@ -121,7 +121,6 @@ export declare class Document extends MalloyElement implements NameSpace {
     globalNameSpace: NameSpace;
     documentModel: Record<string, ModelEntry>;
     queryList: Query[];
-    sqlBlocks: SQLSourceDef[];
     statements: DocStatementList;
     didInitModel: boolean;
     annotation: Annotation;
@@ -134,7 +133,6 @@ export declare class Document extends MalloyElement implements NameSpace {
     hasAnnotation(): boolean;
     currentModelAnnotation(): ModelAnnotation | undefined;
     modelDef(): ModelDef;
-    defineSQL(sql: SQLSourceDef, name?: string): boolean;
     getEntry(str: string): ModelEntry;
     setEntry(str: string, ent: ModelEntry): void;
     /**

package/dist/lang/ast/types/malloy-element.js

@@ -430,7 +430,6 @@ class Document extends MalloyElement {
         this.globalNameSpace = new global_name_space_1.GlobalNameSpace();
         this.documentModel = {};
         this.queryList = [];
-        this.sqlBlocks = [];
         this.didInitModel = false;
         this.annotation = {};
         this.experiments = new tags_1.Tag({});
@@ -445,7 +444,6 @@ class Document extends MalloyElement {
         }
         this.documentModel = {};
         this.queryList = [];
-        this.sqlBlocks = [];
         if (extendingModelDef) {
             if (extendingModelDef.annotation) {
                 this.annotation.inherits = extendingModelDef.annotation;
@@ -471,11 +469,6 @@ class Document extends MalloyElement {
                     q.modelAnnotation = modelDef.annotation;
                 }
             }
-            for (const q of this.sqlBlocks) {
-                if (q.modelAnnotation === undefined && modelDef.annotation) {
-                    q.modelAnnotation = modelDef.annotation;
-                }
-            }
         }
         if (modelDef.annotation) {
             for (const sd of this.modelAnnotationTodoList) {
@@ -483,9 +476,10 @@ class Document extends MalloyElement {
             }
         }
         const ret = {
-            modelDef,
-            queryList: this.queryList,
-            sqlBlocks: this.sqlBlocks,
+            modelDef: {
+                ...modelDef,
+                queryList: this.queryList,
+            },
             needs,
         };
         return ret;
@@ -505,7 +499,13 @@ class Document extends MalloyElement {
         }
     }
     modelDef() {
-        const def = { name: '', exports: [], contents: {} };
+        const def = {
+            name: '',
+            exports: [],
+            contents: {},
+            queryList: [],
+            dependencies: {},
+        };
         if (this.hasAnnotation()) {
             def.annotation = this.currentModelAnnotation();
         }
@@ -524,21 +524,6 @@ class Document extends MalloyElement {
         }
         return def;
     }
-    defineSQL(sql, name) {
-        const ret = {
-            ...sql,
-            as: `$${this.sqlBlocks.length}`,
-        };
-        if (name) {
-            if (this.getEntry(name)) {
-                return false;
-            }
-            ret.as = name;
-            this.setEntry(name, { entry: ret });
-        }
-        this.sqlBlocks.push(ret);
-        return true;
-    }
     getEntry(str) {
         var _a;
         return (_a = this.globalNameSpace.getEntry(str)) !== null && _a !== void 0 ? _a : this.documentModel[str];

package/dist/lang/index.d.ts

@@ -1,4 +1,4 @@
-export { MalloyTranslator } from './parse-malloy';
+export { MalloyTranslator, MalloyTranslation } from './parse-malloy';
 export type { UpdateData, SchemaData, URLData, SQLSources as SQLBlockData, } from './parse-malloy';
 export type { TranslateResponse } from './translate-response';
 export { exploreQueryWalkerBuilder } from './parse-tree-walkers/explore-query-walker';

package/dist/lang/index.js

@@ -22,9 +22,10 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.exploreQueryWalkerBuilder = exports.MalloyTranslator = void 0;
+exports.exploreQueryWalkerBuilder = exports.MalloyTranslation = exports.MalloyTranslator = void 0;
 var parse_malloy_1 = require("./parse-malloy");
 Object.defineProperty(exports, "MalloyTranslator", { enumerable: true, get: function () { return parse_malloy_1.MalloyTranslator; } });
+Object.defineProperty(exports, "MalloyTranslation", { enumerable: true, get: function () { return parse_malloy_1.MalloyTranslation; } });
 var explore_query_walker_1 = require("./parse-tree-walkers/explore-query-walker");
 Object.defineProperty(exports, "exploreQueryWalkerBuilder", { enumerable: true, get: function () { return explore_query_walker_1.exploreQueryWalkerBuilder; } });
 //# sourceMappingURL=index.js.map

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;