@malloydata/malloy 0.0.22-dev230117232218 → 0.0.22-dev230119001546

package/dist/lang/ast/ast-main.js

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurtleHeadedPipe = exports.ExistingQuery = exports.Index = exports.Turtles = exports.Limit = exports.Ordering = exports.OrderBy = exports.WildcardFieldReference = exports.RenameField = exports.PrimaryKey = exports.Document = exports.QOPDesc = exports.Aggregate = exports.GroupBy = exports.FieldListEdit = exports.ProjectStatement = exports.isFieldCollectionMember = exports.FieldReferences = exports.FieldReference = exports.FieldName = exports.Renames = exports.Dimensions = exports.Measures = exports.DeclareFields = exports.Filter = exports.FilterElement = exports.ExploreDesc = exports.isExploreProperty = exports.isQueryProperty = exports.Joins = exports.ExpressionJoin = exports.KeyJoin = exports.Join = exports.QuerySource = exports.SQLSource = exports.NamedSource = exports.ModelEntryReference = exports.IsValueBlock = exports.TableSource = exports.RefinedExplore = exports.DefineSourceList = exports.DefineExplore = exports.isDocStatement = exports.RunList = exports.Mallobj = exports.isExploreField = exports.Unimplemented = exports.ListOf = exports.MalloyElement = exports.ErrorFactory = void 0;
-exports.SampleProperty = exports.SQLStatement = exports.SQLString = exports.ConstantParameter = exports.HasParameter = exports.ImportStatement = exports.JSONStructDef = exports.JSONElement = exports.Top = exports.AnonymousQuery = exports.DefineQuery = exports.DefineQueryList = exports.isQueryElement = exports.Nests = exports.isNestedQuery = exports.NestDefinition = exports.NestRefinement = exports.NestReference = exports.TurtleDecl = exports.FullQuery = void 0;
+exports.Range = exports.ExprTime = exports.ExprDuration = exports.TypeMistmatch = exports.ExprGranularTime = exports.ExprCompare = exports.BinaryBoolean = exports.applyBinary = exports.FieldDeclaration = exports.ConstantSubExpression = exports.ExpressionDef = exports.SampleProperty = exports.SQLStatement = exports.SQLString = exports.ConstantParameter = exports.HasParameter = exports.ImportStatement = exports.JSONStructDef = exports.JSONElement = exports.Top = exports.AnonymousQuery = exports.DefineQuery = exports.DefineQueryList = exports.isQueryElement = exports.Nests = exports.isNestedQuery = exports.NestDefinition = exports.NestRefinement = exports.NestReference = exports.TurtleDecl = exports.FullQuery = void 0;
 /*
  * Copyright 2023 Google LLC
  *
@@ -49,13 +49,15 @@ exports.SampleProperty = exports.SQLStatement = exports.SQLString = exports.Cons
  */
 const lodash_1 = require("lodash");
 const model = __importStar(require("../../model/malloy_types"));
+const malloy_types_1 = require("../../model/malloy_types");
 const malloy_query_1 = require("../../model/malloy_query");
 const field_space_1 = require("../field-space");
-const index_1 = require("./index");
+const ast_types_1 = require("./ast-types");
 const space_field_1 = require("../space-field");
 const sql_block_1 = require("../../model/sql_block");
 const util_1 = require("util");
 const time_utils_1 = require("./time-utils");
+const apply_expr_1 = require("./apply-expr");
 /*
  ** For times when there is a code generation error but your function needs
  ** to return some kind of object to type properly, the ErrorFactory is
@@ -357,7 +359,7 @@ function getStructFieldDef(s, fn) {
     return s.fields.find((fld) => (fld.as || fld.name) === fn);
 }
 function isFieldDecl(f) {
-    return (f instanceof index_1.FieldDeclaration ||
+    return (f instanceof FieldDeclaration ||
         f instanceof Join ||
         f instanceof TurtleDecl ||
         f instanceof Turtles);
@@ -861,7 +863,7 @@ class ExpressionJoin extends Join {
         }
         const joinRel = inStruct.structRelationship;
         if (model.isJoinOn(joinRel)) {
-            joinRel.onExpression = (0, index_1.compressExpr)(exprX.value);
+            joinRel.onExpression = (0, ast_types_1.compressExpr)(exprX.value);
         }
     }
     structDef() {
@@ -940,7 +942,7 @@ class FilterElement extends MalloyElement {
         }
         const exprCond = {
             code: this.exprSrc,
-            expression: (0, index_1.compressExpr)(exprVal.value),
+            expression: (0, ast_types_1.compressExpr)(exprVal.value),
             expressionType: exprVal.expressionType,
         };
         return exprCond;
@@ -1066,7 +1068,7 @@ exports.FieldReferences = FieldReferences;
 function isFieldCollectionMember(el) {
     return (el instanceof FieldReference ||
         el instanceof WildcardFieldReference ||
-        el instanceof index_1.FieldDeclaration);
+        el instanceof FieldDeclaration);
 }
 exports.isFieldCollectionMember = isFieldCollectionMember;
 class ProjectStatement extends ListOf {
@@ -1088,7 +1090,7 @@ class GroupBy extends ListOf {
     constructor(members) {
         super("groupBy", members);
         for (const el of members) {
-            if (el instanceof index_1.FieldDeclaration) {
+            if (el instanceof FieldDeclaration) {
                 el.isMeasure = false;
             }
         }
@@ -1099,7 +1101,7 @@ class Aggregate extends ListOf {
     constructor(members) {
         super("aggregate", members);
         for (const el of members) {
-            if (el instanceof index_1.FieldDeclaration) {
+            if (el instanceof FieldDeclaration) {
                 el.isMeasure = true;
             }
         }
@@ -1933,7 +1935,7 @@ class Top extends MalloyElement {
                 if (model.expressionIsAggregate(byExpr.expressionType)) {
                     this.log("top by expression must be an aggregate");
                 }
-                return { by: "expression", e: (0, index_1.compressExpr)(byExpr.value) };
+                return { by: "expression", e: (0, ast_types_1.compressExpr)(byExpr.value) };
             }
         }
         return undefined;
@@ -2183,4 +2185,674 @@ class SampleProperty extends MalloyElement {
     }
 }
 exports.SampleProperty = SampleProperty;
+/**
+ * Root node for any element in an expression. These essentially
+ * create a sub-tree in the larger AST. Expression nodes know
+ * how to write themselves as SQL (or rather, generate the
+ * template for SQL required by the query writer)
+ */
+class ExpressionDef extends MalloyElement {
+    constructor() {
+        super(...arguments);
+        this.legalChildTypes = ast_types_1.FT.anyAtomicT;
+    }
+    granular() {
+        return false;
+    }
+    /**
+     * Some operators want to give the right hand value a chance to
+     * rewrite itself. This requests a translation for a rewrite,
+     * or returns undefined if that request should be denied.
+     * @param fs FieldSpace
+     * @returns Translated expression or undefined
+     */
+    requestExpression(fs) {
+        return this.getExpression(fs);
+    }
+    defaultFieldName() {
+        return undefined;
+    }
+    /**
+     * Check an expression for type compatibility
+     * @param _eNode currently unused, will be used to get error location
+     * @param eVal ...list of expressions that must match legalChildTypes
+     */
+    typeCheck(eNode, eVal) {
+        if (!ast_types_1.FT.in(eVal, this.legalChildTypes)) {
+            eNode.log(`'${this.elementType}' Can't use type ${ast_types_1.FT.inspect(eVal)}`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * This is the operation which makes partial comparison and value trees work
+     * The default implemention merely constructs LEFT OP RIGHT, but specialized
+     * nodes like alternation trees or or partial comparison can control how
+     * the appplication gets generated
+     * @param fs The symbol table
+     * @param op The operator being applied
+     * @param expr The "other" (besdies 'this') value
+     * @returns The translated expression
+     */
+    apply(fs, op, left) {
+        return applyBinary(fs, left, op, this);
+    }
+}
+exports.ExpressionDef = ExpressionDef;
+class ConstantSubExpression extends ExpressionDef {
+    constructor(expr) {
+        super({ expr });
+        this.expr = expr;
+        this.elementType = "constantExpression";
+    }
+    getExpression(_fs) {
+        return this.constantValue();
+    }
+    get constantFs() {
+        if (!this.cfs) {
+            this.cfs = new ConstantFieldSpace();
+        }
+        return this.cfs;
+    }
+    constantValue() {
+        return this.expr.getExpression(this.constantFs);
+    }
+    constantCondition(type) {
+        const compareAndContrast = new ExprCompare(new DollarReference(type), "=", this.expr);
+        const application = compareAndContrast.getExpression(this.constantFs);
+        return { ...application, value: (0, ast_types_1.compressExpr)(application.value) };
+    }
+    apply(fs, op, expr) {
+        return this.expr.apply(fs, op, expr);
+    }
+    requestExpression(fs) {
+        return this.expr.requestExpression(fs);
+    }
+}
+exports.ConstantSubExpression = ConstantSubExpression;
+class DollarReference extends ExpressionDef {
+    constructor(refType) {
+        super();
+        this.refType = refType;
+        this.elementType = "$";
+    }
+    getExpression(_fs) {
+        return {
+            dataType: this.refType,
+            value: [{ type: "applyVal" }],
+            expressionType: "scalar",
+        };
+    }
+}
+class ConstantFieldSpace {
+    constructor() {
+        this.type = "fieldSpace";
+    }
+    structDef() {
+        throw new Error("ConstantFieldSpace cannot generate a structDef");
+    }
+    emptyStructDef() {
+        throw new Error("ConstantFieldSpace cannot generate a structDef");
+    }
+    lookup(_name) {
+        return {
+            error: "Only constants allowed in parameter expressions",
+            found: undefined,
+        };
+    }
+    dialectObj() {
+        return undefined;
+    }
+    whenComplete(step) {
+        step();
+    }
+}
+class FieldDeclaration extends MalloyElement {
+    constructor(expr, defineName, exprSrc) {
+        super({ expr });
+        this.expr = expr;
+        this.defineName = defineName;
+        this.exprSrc = exprSrc;
+        this.elementType = "fieldDeclaration";
+    }
+    fieldDef(fs, exprName) {
+        /*
+         * In an explore we cannot reference the thing we are defining, you need
+         * to use rename. In a query, the output space is a new thing, and expressions
+         * can reference the outer value in order to make a value with the new name,
+         * and it feels wrong that this is HERE and not somehow in the QueryOperation.
+         * For now, this stops the stack overflow, and passes all tests, but I think
+         * a refactor of QueryFieldSpace might someday be the place where this should
+         * happen.
+         */
+        return this.queryFieldDef(new field_space_1.DefSpace(fs, this), exprName);
+    }
+    queryFieldDef(exprFS, exprName) {
+        let exprValue;
+        try {
+            exprValue = this.expr.getExpression(exprFS);
+        }
+        catch (error) {
+            this.log(`Cannot define '${exprName}', ${error.message}`);
+            return {
+                name: `error_defining_${exprName}`,
+                type: "string",
+            };
+        }
+        const compressValue = (0, ast_types_1.compressExpr)(exprValue.value);
+        const retType = exprValue.dataType;
+        if ((0, malloy_types_1.isAtomicFieldType)(retType)) {
+            const template = {
+                name: exprName,
+                type: retType,
+                location: this.location,
+            };
+            if (compressValue.length > 0) {
+                template.e = compressValue;
+            }
+            if (exprValue.expressionType) {
+                template.expressionType = exprValue.expressionType;
+            }
+            if (this.exprSrc) {
+                template.code = this.exprSrc;
+            }
+            // TODO this should work for dates too
+            if ((0, ast_types_1.isGranularResult)(exprValue) && template.type === "timestamp") {
+                template.timeframe = exprValue.timeframe;
+            }
+            return template;
+        }
+        const circularDef = exprFS instanceof field_space_1.DefSpace && exprFS.foundCircle;
+        if (!circularDef) {
+            if (exprValue.dataType == "unknown") {
+                this.log(`Cannot define '${exprName}', value has unknown type`);
+            }
+            else {
+                const badType = ast_types_1.FT.inspect(exprValue);
+                this.log(`Cannot define '${exprName}', unexpected type: ${badType}`);
+            }
+        }
+        return {
+            name: `error_defining_${exprName}`,
+            type: "string",
+        };
+    }
+}
+exports.FieldDeclaration = FieldDeclaration;
+/**
+ * All of the magic of malloy expressions eventually flows to here,
+ * where an operator is applied to two values. Depending on the
+ * operator and value types this may involve transformations of
+ * the values or even the operator.
+ * @param fs FieldSpace for the symbols
+ * @param left Left value
+ * @param op The operator
+ * @param right Right Value
+ * @returns ExprValue of the expression
+ */
+function applyBinary(fs, left, op, right) {
+    if ((0, ast_types_1.isEquality)(op)) {
+        return equality(fs, left, op, right);
+    }
+    if ((0, ast_types_1.isComparison)(op)) {
+        return compare(fs, left, op, right);
+    }
+    if (oneOf(op, "+", "-")) {
+        return delta(fs, left, op, right);
+    }
+    if (oneOf(op, "*", "%")) {
+        return numeric(fs, left, op, right);
+    }
+    if (oneOf(op, "/")) {
+        const num = left.getExpression(fs);
+        const denom = right.getExpression(fs);
+        if (num.dataType != "number") {
+            left.log("Numerator for division must be a number");
+        }
+        else if (denom.dataType != "number") {
+            right.log("Denominator for division must be a number");
+        }
+        else {
+            const div = {
+                type: "dialect",
+                function: "div",
+                numerator: num.value,
+                denominator: denom.value,
+            };
+            return {
+                dataType: "number",
+                expressionType: (0, malloy_types_1.maxExpressionType)(num.expressionType, denom.expressionType),
+                value: [div],
+            };
+        }
+        return (0, ast_types_1.errorFor)("divide type mismatch");
+    }
+    left.log(`Canot use ${op} operator here`);
+    return (0, ast_types_1.errorFor)("applybinary bad operator");
+}
+exports.applyBinary = applyBinary;
+class BinaryBoolean extends ExpressionDef {
+    constructor(left, op, right) {
+        super({ left, right });
+        this.left = left;
+        this.op = op;
+        this.right = right;
+        this.elementType = "abstract boolean binary";
+        this.legalChildTypes = [ast_types_1.FT.boolT];
+    }
+    getExpression(fs) {
+        const left = this.left.getExpression(fs);
+        const right = this.right.getExpression(fs);
+        if (this.typeCheck(this.left, left) && this.typeCheck(this.right, right)) {
+            return {
+                dataType: "boolean",
+                expressionType: (0, malloy_types_1.maxExpressionType)(left.expressionType, right.expressionType),
+                value: (0, ast_types_1.compose)(left.value, this.op, right.value),
+            };
+        }
+        return (0, ast_types_1.errorFor)("logial required boolean");
+    }
+}
+exports.BinaryBoolean = BinaryBoolean;
+class ExprCompare extends BinaryBoolean {
+    constructor(left, op, right) {
+        super(left, op, right);
+        this.elementType = "a<=>b";
+        this.legalChildTypes = compareTypes[op];
+    }
+    getExpression(fs) {
+        if (!this.right.granular()) {
+            const rhs = this.right.requestExpression(fs);
+            if (rhs && (0, ast_types_1.isGranularResult)(rhs)) {
+                const newRight = new ExprGranularTime(this.right, rhs.timeframe, false);
+                return newRight.apply(fs, this.op, this.left);
+            }
+        }
+        return this.right.apply(fs, this.op, this.left);
+    }
+}
+exports.ExprCompare = ExprCompare;
+function equality(fs, left, op, right) {
+    const lhs = left.getExpression(fs);
+    const rhs = right.getExpression(fs);
+    let value = timeCompare(lhs, op, rhs) || (0, ast_types_1.compose)(lhs.value, op, rhs.value);
+    if (lhs.dataType != "unknown" && rhs.dataType != "unknown") {
+        switch (op) {
+            case "~":
+            case "!~": {
+                if (lhs.dataType === "string" && rhs.dataType === "string") {
+                    value = (0, ast_types_1.compose)(lhs.value, "LIKE", rhs.value);
+                }
+                else {
+                    const regexCmp = regexEqual(lhs, rhs);
+                    if (regexCmp === undefined) {
+                        throw new TypeMistmatch("Incompatible types for match('~') operator");
+                    }
+                    value = regexCmp;
+                }
+                value = (0, apply_expr_1.nullsafeNot)(value, op);
+                break;
+            }
+            case "=":
+            case "!=": {
+                const nullCmp = nullCompare(lhs, op, rhs);
+                if (nullCmp) {
+                    value = nullCmp;
+                }
+                else {
+                    value = (0, apply_expr_1.nullsafeNot)(regexEqual(lhs, rhs) || (0, ast_types_1.compose)(lhs.value, "=", rhs.value), op);
+                }
+                break;
+            }
+        }
+    }
+    return {
+        dataType: "boolean",
+        expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType),
+        value,
+    };
+}
+function compare(fs, left, op, right) {
+    const lhs = left.getExpression(fs);
+    const rhs = right.getExpression(fs);
+    const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
+    const value = timeCompare(lhs, op, rhs) || (0, ast_types_1.compose)(lhs.value, op, rhs.value);
+    return {
+        dataType: "boolean",
+        expressionType,
+        value: value,
+    };
+}
+function oneOf(op, ...operators) {
+    return operators.includes(op);
+}
+function delta(fs, left, op, right) {
+    const lhs = left.getExpression(fs);
+    const rhs = right.getExpression(fs);
+    if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType)) {
+        let duration = right;
+        if (rhs.dataType !== "duration") {
+            if ((0, ast_types_1.isGranularResult)(lhs)) {
+                duration = new ExprDuration(right, lhs.timeframe);
+            }
+            else if (lhs.dataType === "date") {
+                duration = new ExprDuration(right, "day");
+            }
+            else {
+                left.log(`Can not offset time by '${rhs.dataType}'`);
+                return (0, ast_types_1.errorFor)(`time plus ${rhs.dataType}`);
+            }
+        }
+        return duration.apply(fs, op, left);
+    }
+    return numeric(fs, left, op, right);
+}
+function numeric(fs, left, op, right) {
+    const lhs = left.getExpression(fs);
+    const rhs = right.getExpression(fs);
+    const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
+    if (allAre("number", lhs, rhs)) {
+        return {
+            dataType: "number",
+            expressionType,
+            value: (0, ast_types_1.compose)(lhs.value, op, rhs.value),
+        };
+    }
+    left.log(`Non numeric('${lhs.dataType},${rhs.dataType}') value with '${op}'`);
+    return (0, ast_types_1.errorFor)("numbers required");
+}
+const compareTypes = {
+    "~": [ast_types_1.FT.stringT],
+    "!~": [ast_types_1.FT.stringT],
+    "<": [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT],
+    "<=": [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT],
+    "=": [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT],
+    "!=": [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT],
+    ">=": [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT],
+    ">": [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT],
+};
+/**
+ * GranularTime is a moment in time which ALSO has a "granularity"
+ * commonly this are created by applying ".datePart" to an expression
+ * 1) They have a value, which is the moment in time
+ * 2) When used in a comparison, they act like a range, for the
+ *    duration of 1 unit of granularity
+ */
+class ExprGranularTime extends ExpressionDef {
+    constructor(expr, units, truncate) {
+        super({ expr });
+        this.expr = expr;
+        this.units = units;
+        this.truncate = truncate;
+        this.elementType = "granularTime";
+        this.legalChildTypes = [ast_types_1.FT.timestampT, ast_types_1.FT.dateT];
+    }
+    granular() {
+        return true;
+    }
+    getExpression(fs) {
+        const timeframe = this.units;
+        const exprVal = this.expr.getExpression(fs);
+        if ((0, malloy_types_1.isTimeFieldType)(exprVal.dataType)) {
+            const tsVal = {
+                ...exprVal,
+                dataType: exprVal.dataType,
+                timeframe: timeframe,
+            };
+            if (this.truncate) {
+                tsVal.value = [
+                    {
+                        type: "dialect",
+                        function: "trunc",
+                        expr: { value: exprVal.value, valueType: exprVal.dataType },
+                        units: timeframe,
+                    },
+                ];
+            }
+            return tsVal;
+        }
+        this.log(`Cannot do time truncation on type '${exprVal.dataType}'`);
+        return (0, ast_types_1.errorFor)(`granularity typecheck`);
+    }
+    apply(fs, op, left) {
+        const rangeType = this.getExpression(fs).dataType;
+        const _valueType = left.getExpression(fs).dataType;
+        const granularityType = (0, malloy_types_1.isDateUnit)(this.units) ? "date" : "timestamp";
+        if (rangeType == "date" && granularityType == "date") {
+            return this.dateRange(fs, op, left);
+        }
+        return this.timestampRange(fs, op, left);
+        /*
+          write tests for each of these cases ....
+    
+          vt  rt  gt  use
+          dt  dt  dt  dateRange
+          dt  dt  ts  == or timeStampRange
+          dt  ts  dt  timestampRange
+          dt  ts  ts  timeStampRange
+    
+          ts  ts  ts  timestampRange
+          ts  ts  dt  timestampRange
+          ts  dt  ts  timestampRange
+          ts  dt  dt  either
+    
+        */
+    }
+    timestampRange(fs, op, expr) {
+        const begin = this.getExpression(fs);
+        const beginTime = ExprTime.fromValue("timestamp", begin);
+        const endTime = new ExprTime("timestamp", (0, time_utils_1.timeOffset)("timestamp", begin.value, "+", (0, malloy_types_1.mkExpr) `1`, this.units), begin.expressionType);
+        const range = new Range(beginTime, endTime);
+        return range.apply(fs, op, expr);
+    }
+    dateRange(fs, op, expr) {
+        const begin = this.getExpression(fs);
+        const beginTime = new ExprTime("date", begin.value, begin.expressionType);
+        const endAt = (0, time_utils_1.timeOffset)("date", begin.value, "+", ["1"], this.units);
+        const end = new ExprTime("date", endAt, begin.expressionType);
+        const range = new Range(beginTime, end);
+        return range.apply(fs, op, expr);
+    }
+}
+exports.ExprGranularTime = ExprGranularTime;
+function timeCompare(lhs, op, rhs) {
+    if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType) && (0, malloy_types_1.isTimeFieldType)(rhs.dataType)) {
+        if (lhs.dataType !== rhs.dataType) {
+            let lval = lhs.value;
+            let rval = rhs.value;
+            if (lhs.dataType === "timestamp") {
+                lval = (0, time_utils_1.castTimestampToDate)(lval);
+            }
+            else {
+                rval = (0, time_utils_1.castTimestampToDate)(rval);
+            }
+            return (0, ast_types_1.compose)(lval, op, rval);
+        }
+    }
+    return undefined;
+}
+function regexEqual(left, right) {
+    if (left.dataType === "string") {
+        if (right.dataType === "regular expression") {
+            return [
+                {
+                    type: "dialect",
+                    function: "regexpMatch",
+                    expr: left.value,
+                    regexp: right.value[0].replace(/^r'/, "'"),
+                },
+            ];
+        }
+    }
+    else if (right.dataType === "string") {
+        if (left.dataType === "regular expression") {
+            return [
+                {
+                    type: "dialect",
+                    function: "regexpMatch",
+                    expr: right.value,
+                    regexp: left.value[0].replace(/^r'/, "'"),
+                },
+            ];
+        }
+    }
+    return undefined;
+}
+class TypeMistmatch extends Error {
+}
+exports.TypeMistmatch = TypeMistmatch;
+function nullCompare(left, op, right) {
+    const not = op === "!=" || op === "!~";
+    if (left.dataType === "null" || right.dataType === "null") {
+        const maybeNot = not ? " NOT" : "";
+        if (left.dataType !== "null") {
+            return [...left.value, ` IS${maybeNot} NULL`];
+        }
+        if (right.dataType !== "null") {
+            return [...right.value, `IS${maybeNot} NULL`];
+        }
+        return [not ? "false" : "true"];
+    }
+    return undefined;
+}
+class ExprDuration extends ExpressionDef {
+    constructor(n, timeframe) {
+        super({ n });
+        this.n = n;
+        this.timeframe = timeframe;
+        this.elementType = "duration";
+        this.legalChildTypes = [ast_types_1.FT.timestampT, ast_types_1.FT.dateT];
+    }
+    apply(fs, op, left) {
+        const lhs = left.getExpression(fs);
+        this.typeCheck(this, lhs);
+        if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType) && (op === "+" || op === "-")) {
+            const num = this.n.getExpression(fs);
+            if (!ast_types_1.FT.typeEq(num, ast_types_1.FT.numberT)) {
+                this.log(`Duration units needs number not '${num.dataType}`);
+                return (0, ast_types_1.errorFor)("illegal unit expression");
+            }
+            let resultGranularity;
+            // Only allow the output of this to be granular if the
+            // granularities match, this is still an area where
+            // more thought is required.
+            if ((0, ast_types_1.isGranularResult)(lhs) && lhs.timeframe == this.timeframe) {
+                resultGranularity = lhs.timeframe;
+            }
+            if (lhs.dataType === "timestamp") {
+                const result = (0, time_utils_1.timeOffset)("timestamp", lhs.value, op, num.value, this.timeframe);
+                return (0, time_utils_1.timeResult)({
+                    dataType: "timestamp",
+                    expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
+                    value: result,
+                }, resultGranularity);
+            }
+            return (0, time_utils_1.timeResult)({
+                dataType: "date",
+                expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
+                value: (0, time_utils_1.timeOffset)("date", lhs.value, op, num.value, this.timeframe),
+            }, resultGranularity);
+        }
+        return super.apply(fs, op, left);
+    }
+    getExpression(_fs) {
+        return {
+            dataType: "duration",
+            expressionType: "scalar",
+            value: ["__ERROR_DURATION_IS_NOT_A_VALUE__"],
+        };
+    }
+}
+exports.ExprDuration = ExprDuration;
+function allAre(oneType, ...values) {
+    for (const v of values) {
+        if (v.dataType !== oneType) {
+            return false;
+        }
+    }
+    return true;
+}
+class ExprTime extends ExpressionDef {
+    constructor(timeType, value, expressionType = "scalar") {
+        super();
+        this.elementType = "timestampOrDate";
+        this.elementType = timeType;
+        this.translationValue = {
+            dataType: timeType,
+            expressionType,
+            value: typeof value === "string" ? [value] : value,
+        };
+    }
+    getExpression(_fs) {
+        return this.translationValue;
+    }
+    static fromValue(timeType, expr) {
+        let value = expr.value;
+        if (timeType != expr.dataType) {
+            const toTs = {
+                type: "dialect",
+                function: "cast",
+                safe: false,
+                dstType: timeType,
+                expr: expr.value,
+            };
+            if ((0, malloy_types_1.isTimeFieldType)(expr.dataType)) {
+                toTs.srcType = expr.dataType;
+            }
+            value = (0, ast_types_1.compressExpr)([toTs]);
+        }
+        return new ExprTime(timeType, value, expr.expressionType);
+    }
+}
+exports.ExprTime = ExprTime;
+class Range extends ExpressionDef {
+    constructor(first, last) {
+        super({ first, last });
+        this.first = first;
+        this.last = last;
+        this.elementType = "range";
+    }
+    apply(fs, op, expr) {
+        switch (op) {
+            case "=":
+            case "!=": {
+                const op1 = op === "=" ? ">=" : "<";
+                const op2 = op === "=" ? "and" : "or";
+                const op3 = op === "=" ? "<" : ">=";
+                const fromValue = this.first.apply(fs, op1, expr);
+                const toValue = this.last.apply(fs, op3, expr);
+                return {
+                    dataType: "boolean",
+                    expressionType: (0, malloy_types_1.maxExpressionType)(fromValue.expressionType, toValue.expressionType),
+                    value: (0, ast_types_1.compose)(fromValue.value, op2, toValue.value),
+                };
+            }
+            /**
+             * This is a little surprising, but is actually how you comapre a
+             * value to a range ...
+             *
+             * val > begin to end     val >= end
+             * val >= begin to end    val >= begin
+             * val < begin to end     val < begin
+             * val <= begin to end    val < end
+             */
+            case ">":
+                return this.last.apply(fs, ">=", expr);
+            case ">=":
+                return this.first.apply(fs, ">=", expr);
+            case "<":
+                return this.first.apply(fs, "<", expr);
+            case "<=":
+                return this.last.apply(fs, "<", expr);
+        }
+        throw new Error("mysterious error in range computation");
+    }
+    requestExpression(_fs) {
+        return undefined;
+    }
+    getExpression(_fs) {
+        return (0, ast_types_1.errorFor)("a range is not a value");
+    }
+}
+exports.Range = Range;
 //# sourceMappingURL=ast-main.js.map