@malloydata/malloy 0.0.22-dev230117223957 → 0.0.22-dev230119001546

package/dist/lang/ast/apply-expr.d.ts

@@ -1,16 +1,3 @@
 import { Expr } from "../../model/malloy_types";
-import { FieldSpace } from "../field-space";
-import { ExprValue, ExpressionDef, Equality } from "./index";
-/**
- * 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
- */
-export declare function applyBinary(fs: FieldSpace, left: ExpressionDef, op: string, right: ExpressionDef): ExprValue;
+import { Equality } from "./ast-types";
 export declare function nullsafeNot(expr: Expr, op?: Equality): Expr;

package/dist/lang/ast/apply-expr.js

@@ -22,129 +22,8 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nullsafeNot = exports.applyBinary = void 0;
+exports.nullsafeNot = void 0;
 const malloy_types_1 = require("../../model/malloy_types");
-const index_1 = require("./index");
-/**
- * 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, index_1.isEquality)(op)) {
-        return equality(fs, left, op, right);
-    }
-    if ((0, index_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, index_1.errorFor)("divide type mismatch");
-    }
-    left.log(`Canot use ${op} operator here`);
-    return (0, index_1.errorFor)("applybinary bad operator");
-}
-exports.applyBinary = applyBinary;
-function oneOf(op, ...operators) {
-    return operators.includes(op);
-}
-function allAre(oneType, ...values) {
-    for (const v of values) {
-        if (v.dataType !== oneType) {
-            return false;
-        }
-    }
-    return true;
-}
-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;
-}
-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;
-}
-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, index_1.castTimestampToDate)(lval);
-            }
-            else {
-                rval = (0, index_1.castTimestampToDate)(rval);
-            }
-            return (0, index_1.compose)(lval, op, rval);
-        }
-    }
-    return undefined;
-}
 function nullsafeNot(expr, op) {
     if (op === undefined || op === "!=" || op === "!~") {
         return (0, malloy_types_1.mkExpr) `COALESCE(NOT(${expr}),FALSE)`;
@@ -152,90 +31,4 @@ function nullsafeNot(expr, op) {
     return expr;
 }
 exports.nullsafeNot = nullsafeNot;
-function equality(fs, left, op, right) {
-    const lhs = left.getExpression(fs);
-    const rhs = right.getExpression(fs);
-    let value = timeCompare(lhs, op, rhs) || (0, index_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, index_1.compose)(lhs.value, "LIKE", rhs.value);
-                }
-                else {
-                    const regexCmp = regexEqual(lhs, rhs);
-                    if (regexCmp === undefined) {
-                        throw new index_1.TypeMistmatch("Incompatible types for match('~') operator");
-                    }
-                    value = regexCmp;
-                }
-                value = nullsafeNot(value, op);
-                break;
-            }
-            case "=":
-            case "!=": {
-                const nullCmp = nullCompare(lhs, op, rhs);
-                if (nullCmp) {
-                    value = nullCmp;
-                }
-                else {
-                    value = nullsafeNot(regexEqual(lhs, rhs) || (0, index_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, index_1.compose)(lhs.value, op, rhs.value);
-    return {
-        dataType: "boolean",
-        expressionType,
-        value: value,
-    };
-}
-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, index_1.compose)(lhs.value, op, rhs.value),
-        };
-    }
-    left.log(`Non numeric('${lhs.dataType},${rhs.dataType}') value with '${op}'`);
-    return (0, index_1.errorFor)("numbers required");
-}
-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, index_1.isGranularResult)(lhs)) {
-                duration = new index_1.ExprDuration(right, lhs.timeframe);
-            }
-            else if (lhs.dataType === "date") {
-                duration = new index_1.ExprDuration(right, "day");
-            }
-            else {
-                left.log(`Can not offset time by '${rhs.dataType}'`);
-                return (0, index_1.errorFor)(`time plus ${rhs.dataType}`);
-            }
-        }
-        return duration.apply(fs, op, left);
-    }
-    return numeric(fs, left, op, right);
-}
 //# sourceMappingURL=apply-expr.js.map

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

@@ -1,75 +1,7 @@
-import { By, AtomicFieldType, FieldTypeDef, Fragment, TimeFieldType, ExpressionType } from "../../model/malloy_types";
+import { By, ExpressionType } from "../../model/malloy_types";
 import { FieldSpace } from "../field-space";
-import { Filter, MalloyElement, ExprValue, FieldValueType, FragType } from "./index";
-import { FieldName, FieldReference } from "./ast-main";
-/**
- * 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)
- */
-export declare abstract class ExpressionDef extends MalloyElement {
-    abstract elementType: string;
-    granular(): boolean;
-    /**
-     * Returns the "translation" or template for SQL generation. When asking
-     * for a tranlsation you may pass the types you can accept, allowing
-     * the translation code a chance to convert to match your expectations
-     * @param space Namespace for looking up field references
-     */
-    abstract getExpression(fs: FieldSpace): ExprValue;
-    legalChildTypes: FragType[];
-    /**
-     * 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: FieldSpace): ExprValue | undefined;
-    defaultFieldName(): string | 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: ExpressionDef, eVal: ExprValue): boolean;
-    /**
-     * 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: FieldSpace, op: string, left: ExpressionDef): ExprValue;
-}
-export declare class ConstantSubExpression extends ExpressionDef {
-    readonly expr: ExpressionDef;
-    elementType: string;
-    private cfs?;
-    constructor(expr: ExpressionDef);
-    getExpression(_fs: FieldSpace): ExprValue;
-    private get constantFs();
-    constantValue(): ExprValue;
-    constantCondition(type: AtomicFieldType): ExprValue;
-    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(fs: FieldSpace): ExprValue | undefined;
-}
-export declare class FieldDeclaration extends MalloyElement {
-    readonly expr: ExpressionDef;
-    readonly defineName: string;
-    readonly exprSrc?: string | undefined;
-    elementType: string;
-    isMeasure?: boolean;
-    constructor(expr: ExpressionDef, defineName: string, exprSrc?: string | undefined);
-    fieldDef(fs: FieldSpace, exprName: string): FieldTypeDef;
-    queryFieldDef(exprFS: FieldSpace, exprName: string): FieldTypeDef;
-}
-export declare class TypeMistmatch extends Error {
-}
+import { BinaryBoolean, ExpressionDef, ExprCompare, FieldName, FieldReference, Filter, MalloyElement } from "./ast-main";
+import { ExprValue, FieldValueType, FragType } from "./ast-types";
 export declare class ExprString extends ExpressionDef {
     elementType: string;
     value: string;
@@ -89,13 +21,6 @@ export declare class ExprRegEx extends ExpressionDef {
     constructor(regex: string);
     getExpression(): ExprValue;
 }
-export declare class ExprTime extends ExpressionDef {
-    elementType: string;
-    readonly translationValue: ExprValue;
-    constructor(timeType: TimeFieldType, value: Fragment[] | string, expressionType?: ExpressionType);
-    getExpression(_fs: FieldSpace): ExprValue;
-    static fromValue(timeType: TimeFieldType, expr: ExprValue): ExprTime;
-}
 declare abstract class Unary extends ExpressionDef {
     readonly expr: ExpressionDef;
     constructor(expr: ExpressionDef);
@@ -112,15 +37,6 @@ export declare class Boolean extends ExpressionDef {
     constructor(value: "true" | "false");
     getExpression(): ExprValue;
 }
-export declare abstract class BinaryBoolean<opType extends string> extends ExpressionDef {
-    readonly left: ExpressionDef;
-    readonly op: opType;
-    readonly right: ExpressionDef;
-    elementType: string;
-    legalChildTypes: FragType[];
-    constructor(left: ExpressionDef, op: opType, right: ExpressionDef);
-    getExpression(fs: FieldSpace): ExprValue;
-}
 export declare class ExprLogicalOp extends BinaryBoolean<"and" | "or"> {
     elementType: string;
     legalChildTypes: (FragType | {
@@ -267,15 +183,6 @@ export declare class TopBy extends MalloyElement {
     constructor(by: string | ExpressionDef);
     getBy(fs: FieldSpace): By;
 }
-export declare class Range extends ExpressionDef {
-    readonly first: ExpressionDef;
-    readonly last: ExpressionDef;
-    elementType: string;
-    constructor(first: ExpressionDef, last: ExpressionDef);
-    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(_fs: FieldSpace): ExprValue | undefined;
-    getExpression(_fs: FieldSpace): ExprValue;
-}
 export declare class PickWhen extends MalloyElement {
     readonly pick: ExpressionDef | undefined;
     readonly when: ExpressionDef;
@@ -291,4 +198,10 @@ export declare class Pick extends ExpressionDef {
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
     getExpression(fs: FieldSpace): ExprValue;
 }
+export declare class Apply extends ExprCompare {
+    readonly left: ExpressionDef;
+    readonly right: ExpressionDef;
+    elementType: string;
+    constructor(left: ExpressionDef, right: ExpressionDef);
+}
 export {};