@malloydata/malloy 0.0.22-dev230117232218 → 0.0.22-dev230119001546

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

@@ -1,31 +1,12 @@
 import { TimestampUnit, ExtractUnit, TimeFieldType } from "../../model/malloy_types";
 import { FieldSpace } from "../field-space";
-import { ExpressionDef, BinaryBoolean, ExprValue, MalloyElement, Comparison } from "./index";
+import { Comparison, ExprValue } from "./ast-types";
+import { ExpressionDef, MalloyElement } from "./ast-main";
 export declare class Timeframe extends MalloyElement {
     elementType: string;
     readonly text: TimestampUnit;
     constructor(timeframeName: string);
 }
-/**
- * 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
- */
-export declare class ExprGranularTime extends ExpressionDef {
-    readonly expr: ExpressionDef;
-    readonly units: TimestampUnit;
-    readonly truncate: boolean;
-    elementType: string;
-    legalChildTypes: import("./ast-types").FragType[];
-    constructor(expr: ExpressionDef, units: TimestampUnit, truncate: boolean);
-    granular(): boolean;
-    getExpression(fs: FieldSpace): ExprValue;
-    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
-    protected timestampRange(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-    protected dateRange(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-}
 /**
  * GranularTime made from a literal. Funky because it doesn't know if it
  * is a date or a timestamp in many cases until it is applied.
@@ -46,26 +27,6 @@ export declare class ExprNow extends ExpressionDef {
     elementType: string;
     getExpression(_fs: FieldSpace): ExprValue;
 }
-export declare class ExprDuration extends ExpressionDef {
-    readonly n: ExpressionDef;
-    readonly timeframe: TimestampUnit;
-    elementType: string;
-    legalChildTypes: import("./ast-types").FragType[];
-    constructor(n: ExpressionDef, timeframe: TimestampUnit);
-    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
-    getExpression(_fs: FieldSpace): ExprValue;
-}
-export declare class ExprCompare extends BinaryBoolean<Comparison> {
-    elementType: string;
-    constructor(left: ExpressionDef, op: Comparison, right: ExpressionDef);
-    getExpression(fs: FieldSpace): ExprValue;
-}
-export declare class Apply extends ExprCompare {
-    readonly left: ExpressionDef;
-    readonly right: ExpressionDef;
-    elementType: string;
-    constructor(left: ExpressionDef, right: ExpressionDef);
-}
 export declare class PartialCompare extends ExpressionDef {
     readonly op: Comparison;
     readonly right: ExpressionDef;

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

@@ -22,11 +22,13 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExprFunc = exports.ExprTimeExtract = exports.ForRange = exports.PartialCompare = exports.Apply = exports.ExprCompare = exports.ExprDuration = exports.ExprNow = exports.GranularLiteral = exports.ExprGranularTime = exports.Timeframe = void 0;
+exports.ExprFunc = exports.ExprTimeExtract = exports.ForRange = exports.PartialCompare = exports.ExprNow = exports.GranularLiteral = exports.Timeframe = void 0;
 const luxon_1 = require("luxon");
 const malloy_types_1 = require("../../model/malloy_types");
-const index_1 = require("./index");
-class Timeframe extends index_1.MalloyElement {
+const ast_types_1 = require("./ast-types");
+const time_utils_1 = require("./time-utils");
+const ast_main_1 = require("./ast-main");
+class Timeframe extends ast_main_1.MalloyElement {
     constructor(timeframeName) {
         super();
         this.elementType = "timeframe";
@@ -38,95 +40,11 @@ class Timeframe extends index_1.MalloyElement {
     }
 }
 exports.Timeframe = Timeframe;
-/**
- * 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 index_1.ExpressionDef {
-    constructor(expr, units, truncate) {
-        super({ expr });
-        this.expr = expr;
-        this.units = units;
-        this.truncate = truncate;
-        this.elementType = "granularTime";
-        this.legalChildTypes = [index_1.FT.timestampT, index_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, index_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 = index_1.ExprTime.fromValue("timestamp", begin);
-        const endTime = new index_1.ExprTime("timestamp", (0, index_1.timeOffset)("timestamp", begin.value, "+", (0, malloy_types_1.mkExpr) `1`, this.units), begin.expressionType);
-        const range = new index_1.Range(beginTime, endTime);
-        return range.apply(fs, op, expr);
-    }
-    dateRange(fs, op, expr) {
-        const begin = this.getExpression(fs);
-        const beginTime = new index_1.ExprTime("date", begin.value, begin.expressionType);
-        const endAt = (0, index_1.timeOffset)("date", begin.value, "+", ["1"], this.units);
-        const end = new index_1.ExprTime("date", endAt, begin.expressionType);
-        const range = new index_1.Range(beginTime, end);
-        return range.apply(fs, op, expr);
-    }
-}
-exports.ExprGranularTime = ExprGranularTime;
 /**
  * GranularTime made from a literal. Funky because it doesn't know if it
  * is a date or a timestamp in many cases until it is applied.
  */
-class GranularLiteral extends index_1.ExpressionDef {
+class GranularLiteral extends ast_main_1.ExpressionDef {
     constructor(moment, until, units) {
         super();
         this.moment = moment;
@@ -207,7 +125,7 @@ class GranularLiteral extends index_1.ExpressionDef {
             if (lhs.dataType === "date" && !this.timeType) {
                 rangeType = "date";
             }
-            const range = new index_1.Range(new index_1.ExprTime(rangeType, (0, index_1.timeLiteral)(this.moment, rangeType, "UTC")), new index_1.ExprTime(rangeType, (0, index_1.timeLiteral)(this.until, rangeType, "UTC")));
+            const range = new ast_main_1.Range(new ast_main_1.ExprTime(rangeType, (0, time_utils_1.timeLiteral)(this.moment, rangeType, "UTC")), new ast_main_1.ExprTime(rangeType, (0, time_utils_1.timeLiteral)(this.until, rangeType, "UTC")));
             return range.apply(fs, op, left);
         }
         return super.apply(fs, op, left);
@@ -217,7 +135,7 @@ class GranularLiteral extends index_1.ExpressionDef {
         const value = {
             dataType,
             expressionType: "scalar",
-            value: (0, index_1.timeLiteral)(this.moment, dataType, "UTC"),
+            value: (0, time_utils_1.timeLiteral)(this.moment, dataType, "UTC"),
         };
         // Literals with date resolution can be used as timestamps or dates,
         // this is the third attempt to make that work. It still feels like
@@ -238,7 +156,7 @@ class GranularLiteral extends index_1.ExpressionDef {
     }
 }
 exports.GranularLiteral = GranularLiteral;
-class ExprNow extends index_1.ExpressionDef {
+class ExprNow extends ast_main_1.ExpressionDef {
     constructor() {
         super(...arguments);
         this.elementType = "timestamp";
@@ -257,93 +175,7 @@ class ExprNow extends index_1.ExpressionDef {
     }
 }
 exports.ExprNow = ExprNow;
-class ExprDuration extends index_1.ExpressionDef {
-    constructor(n, timeframe) {
-        super({ n });
-        this.n = n;
-        this.timeframe = timeframe;
-        this.elementType = "duration";
-        this.legalChildTypes = [index_1.FT.timestampT, index_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 (!index_1.FT.typeEq(num, index_1.FT.numberT)) {
-                this.log(`Duration units needs number not '${num.dataType}`);
-                return (0, index_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, index_1.isGranularResult)(lhs) && lhs.timeframe == this.timeframe) {
-                resultGranularity = lhs.timeframe;
-            }
-            if (lhs.dataType === "timestamp") {
-                const result = (0, index_1.timeOffset)("timestamp", lhs.value, op, num.value, this.timeframe);
-                return (0, index_1.timeResult)({
-                    dataType: "timestamp",
-                    expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
-                    value: result,
-                }, resultGranularity);
-            }
-            return (0, index_1.timeResult)({
-                dataType: "date",
-                expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
-                value: (0, index_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;
-class ExprCompare extends index_1.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, index_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;
-class Apply extends ExprCompare {
-    constructor(left, right) {
-        super(left, "=", right);
-        this.left = left;
-        this.right = right;
-        this.elementType = "apply";
-    }
-}
-exports.Apply = Apply;
-const compareTypes = {
-    "~": [index_1.FT.stringT],
-    "!~": [index_1.FT.stringT],
-    "<": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
-    "<=": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
-    "=": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
-    "!=": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
-    ">=": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
-    ">": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
-};
-class PartialCompare extends index_1.ExpressionDef {
+class PartialCompare extends ast_main_1.ExpressionDef {
     constructor(op, right) {
         super({ right });
         this.op = op;
@@ -361,7 +193,7 @@ class PartialCompare extends index_1.ExpressionDef {
     }
     getExpression(_fs) {
         this.log(`Partial comparison does not have a value`);
-        return (0, index_1.errorFor)("no value for partial compare");
+        return (0, ast_types_1.errorFor)("no value for partial compare");
     }
 }
 exports.PartialCompare = PartialCompare;
@@ -369,30 +201,30 @@ exports.PartialCompare = PartialCompare;
  * TODO: This is sort of a hand clone of the "Range" class, they should
  * be siblings of a common abstract classs.
  */
-class ForRange extends index_1.ExpressionDef {
+class ForRange extends ast_main_1.ExpressionDef {
     constructor(from, duration, timeframe) {
         super({ from, duration, timeframe });
         this.from = from;
         this.duration = duration;
         this.timeframe = timeframe;
         this.elementType = "forRange";
-        this.legalChildTypes = [index_1.FT.timestampT, index_1.FT.dateT];
+        this.legalChildTypes = [ast_types_1.FT.timestampT, ast_types_1.FT.dateT];
     }
     apply(fs, op, expr) {
         const startV = this.from.getExpression(fs);
         const checkV = expr.getExpression(fs);
         if (!this.typeCheck(expr, checkV)) {
-            return (0, index_1.errorFor)("no time for range");
+            return (0, ast_types_1.errorFor)("no time for range");
         }
         const nV = this.duration.getExpression(fs);
         if (nV.dataType !== "number") {
             this.log(`FOR duration count must be a number, not '${nV.dataType}'`);
-            return (0, index_1.errorFor)("FOR not number");
+            return (0, ast_types_1.errorFor)("FOR not number");
         }
         const units = this.timeframe.text;
         // If the duration resolution is smaller than date, we have
         // to do the computaion with timestamps.
-        const durationRes = (0, index_1.resolution)(units);
+        const durationRes = (0, time_utils_1.resolution)(units);
         let rangeType = durationRes;
         // Next, if the beginning of the range is a timestamp, then we
         // also have to do the computation as a timestamp
@@ -402,38 +234,38 @@ class ForRange extends index_1.ExpressionDef {
         // everything is dates, do date math
         if (checkV.dataType === "date" && rangeType === "date") {
             const rangeStart = this.from;
-            const rangeEndV = (0, index_1.timeOffset)("date", startV.value, "+", nV.value, units);
-            const rangeEnd = new index_1.ExprTime("date", rangeEndV);
-            return new index_1.Range(rangeStart, rangeEnd).apply(fs, op, expr);
+            const rangeEndV = (0, time_utils_1.timeOffset)("date", startV.value, "+", nV.value, units);
+            const rangeEnd = new ast_main_1.ExprTime("date", rangeEndV);
+            return new ast_main_1.Range(rangeStart, rangeEnd).apply(fs, op, expr);
         }
         // Now it doesn't matter if the range is a date or a timestamp,
         // the comparison will be in timestamp space,
-        const applyTo = index_1.ExprTime.fromValue("timestamp", checkV);
+        const applyTo = ast_main_1.ExprTime.fromValue("timestamp", checkV);
         let rangeStart = this.from;
         let from = startV.value;
         if (startV.dataType === "date") {
             // Time literals with timestamp units can also be used as timestamps;
-            const alreadyTs = (0, index_1.isGranularResult)(startV) && startV.alsoTimestamp;
+            const alreadyTs = (0, ast_types_1.isGranularResult)(startV) && startV.alsoTimestamp;
             if (!alreadyTs) {
                 // ... not a literal, need a cast
-                from = (0, index_1.castDateToTimestamp)(from);
+                from = (0, time_utils_1.castDateToTimestamp)(from);
             }
-            rangeStart = new index_1.ExprTime("timestamp", from, startV.expressionType);
+            rangeStart = new ast_main_1.ExprTime("timestamp", from, startV.expressionType);
         }
-        const to = (0, index_1.timeOffset)("timestamp", from, "+", nV.value, units);
-        const rangeEnd = new index_1.ExprTime("timestamp", to, startV.expressionType);
-        return new index_1.Range(rangeStart, rangeEnd).apply(fs, op, applyTo);
+        const to = (0, time_utils_1.timeOffset)("timestamp", from, "+", nV.value, units);
+        const rangeEnd = new ast_main_1.ExprTime("timestamp", to, startV.expressionType);
+        return new ast_main_1.Range(rangeStart, rangeEnd).apply(fs, op, applyTo);
     }
     requestExpression(_fs) {
         return undefined;
     }
     getExpression(_fs) {
         this.log("A Range is not a value");
-        return (0, index_1.errorFor)("range has no value");
+        return (0, ast_types_1.errorFor)("range has no value");
     }
 }
 exports.ForRange = ForRange;
-class ExprTimeExtract extends index_1.ExpressionDef {
+class ExprTimeExtract extends ast_main_1.ExpressionDef {
     constructor(extractText, args) {
         super({ args });
         this.extractText = extractText;
@@ -454,23 +286,23 @@ class ExprTimeExtract extends index_1.ExpressionDef {
         if (extractTo) {
             if (this.args.length !== 1) {
                 this.log(`Extraction function ${extractTo} requires one argument`);
-                return (0, index_1.errorFor)(`{this.name} arg count`);
+                return (0, ast_types_1.errorFor)(`{this.name} arg count`);
             }
             const from = this.args[0];
-            if (from instanceof index_1.Range) {
+            if (from instanceof ast_main_1.Range) {
                 const first = from.first.getExpression(fs);
                 const last = from.last.getExpression(fs);
                 if (!(0, malloy_types_1.isTimeFieldType)(first.dataType)) {
                     from.first.log(`Can't extract ${extractTo} from '${first.dataType}'`);
-                    return (0, index_1.errorFor)(`${extractTo} bad type ${first.dataType}`);
+                    return (0, ast_types_1.errorFor)(`${extractTo} bad type ${first.dataType}`);
                 }
                 if (!(0, malloy_types_1.isTimeFieldType)(last.dataType)) {
                     from.last.log(`Cannot extract ${extractTo} from '${last.dataType}'`);
-                    return (0, index_1.errorFor)(`${extractTo} bad type ${last.dataType}`);
+                    return (0, ast_types_1.errorFor)(`${extractTo} bad type ${last.dataType}`);
                 }
                 if (!(0, malloy_types_1.isTimestampUnit)(extractTo)) {
                     this.log(`Cannot extract ${extractTo} from a range`);
-                    return (0, index_1.errorFor)(`${extractTo} bad extraction`);
+                    return (0, ast_types_1.errorFor)(`${extractTo} bad extraction`);
                 }
                 return {
                     dataType: "number",
@@ -503,7 +335,7 @@ class ExprTimeExtract extends index_1.ExpressionDef {
                     };
                 }
                 this.log(`${this.extractText}() requires time type, not '${argV.dataType}'`);
-                return (0, index_1.errorFor)(`${this.extractText} bad type ${argV.dataType}`);
+                return (0, ast_types_1.errorFor)(`${this.extractText} bad type ${argV.dataType}`);
             }
         }
         throw this.internalError(`Illegal extraction unit '${this.extractText}'`);
@@ -520,7 +352,7 @@ ExprTimeExtract.pluralMap = {
     minutes: "minute",
     seconds: "second",
 };
-class ExprFunc extends index_1.ExpressionDef {
+class ExprFunc extends ast_main_1.ExpressionDef {
     constructor(name, args) {
         super({ args });
         this.name = name;
@@ -549,7 +381,7 @@ class ExprFunc extends index_1.ExpressionDef {
         return {
             dataType: dataType,
             expressionType,
-            value: (0, index_1.compressExpr)(funcCall),
+            value: (0, ast_types_1.compressExpr)(funcCall),
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.22-dev230117232218",
+  "version": "0.0.22-dev230119001546",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",