@malloydata/malloy 0.0.24-dev230302224355 → 0.0.24-dev230306192917

package/dist/lang/ast/expressions/for-range.d.ts

@@ -2,10 +2,6 @@ import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
 import { Timeframe } from './time-frame';
-/**
- * TODO: This is sort of a hand clone of the "Range" class, they should
- * be siblings of a common abstract classs.
- */
 export declare class ForRange extends ExpressionDef {
     readonly from: ExpressionDef;
     readonly duration: ExpressionDef;
@@ -14,6 +10,6 @@ export declare class ForRange extends ExpressionDef {
     legalChildTypes: import("../types/type-desc").TypeDesc[];
     constructor(from: ExpressionDef, duration: ExpressionDef, timeframe: Timeframe);
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    requestExpression(_fs: FieldSpace): undefined;
     getExpression(_fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/for-range.js

@@ -27,13 +27,8 @@ const ast_utils_1 = require("../ast-utils");
 const fragtype_utils_1 = require("../fragtype-utils");
 const time_utils_1 = require("../time-utils");
 const expression_def_1 = require("../types/expression-def");
-const granular_result_1 = require("../types/granular-result");
 const expr_time_1 = require("./expr-time");
 const range_1 = require("./range");
-/**
- * TODO: This is sort of a hand clone of the "Range" class, they should
- * be siblings of a common abstract classs.
- */
 class ForRange extends expression_def_1.ExpressionDef {
     constructor(from, duration, timeframe) {
         super({ from: from, duration: duration, timeframe: timeframe });
@@ -57,8 +52,7 @@ class ForRange extends expression_def_1.ExpressionDef {
         const units = this.timeframe.text;
         // If the duration resolution is smaller than date, we have
         // to do the computaion with timestamps.
-        const durationRes = (0, time_utils_1.resolution)(units);
-        let rangeType = durationRes;
+        let rangeType = (0, time_utils_1.resolution)(units);
         // Next, if the beginning of the range is a timestamp, then we
         // also have to do the computation as a timestamp
         if (startV.dataType === 'timestamp') {
@@ -77,10 +71,11 @@ class ForRange extends expression_def_1.ExpressionDef {
         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, granular_result_1.isGranularResult)(startV) && startV.alsoTimestamp;
-            if (!alreadyTs) {
-                // ... not a literal, need a cast
+            const tsVersion = startV.morphic && startV.morphic['timestamp'];
+            if (tsVersion) {
+                from = tsVersion;
+            }
+            else {
                 from = (0, time_utils_1.castDateToTimestamp)(from);
             }
             rangeStart = new expr_time_1.ExprTime('timestamp', from, startV.expressionType);

package/dist/lang/ast/expressions/range.d.ts

@@ -7,6 +7,6 @@ export declare class Range extends ExpressionDef {
     elementType: string;
     constructor(first: ExpressionDef, last: ExpressionDef);
     apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    requestExpression(_fs: FieldSpace): undefined;
     getExpression(_fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/range.js

@@ -73,6 +73,7 @@ class Range extends expression_def_1.ExpressionDef {
         return undefined;
     }
     getExpression(_fs) {
+        this.log('A Range is not a value');
         return (0, ast_utils_1.errorFor)('a range is not a value');
     }
 }

package/dist/lang/ast/expressions/time-literal.d.ts

@@ -0,0 +1,77 @@
+import { TimeFieldType, TimestampUnit, TimeLiteralFragment } from '../../../model/malloy_types';
+import { ExprValue } from '../types/expr-value';
+import { FieldSpace } from '../types/field-space';
+import { ExpressionDef } from '../types/expression-def';
+import { TimeResult } from '../types/time-result';
+export declare class TimeFormatError extends Error {
+}
+interface TimeText {
+    text: string;
+    tzSpec?: string;
+    isLocale?: boolean;
+}
+/**
+ * Literals specified with an @ in Malloy all become one of these
+ */
+declare abstract class TimeLiteral extends ExpressionDef {
+    readonly units: TimestampUnit | undefined;
+    readonly timeType: TimeFieldType;
+    literalPart: string;
+    nextLit?: string;
+    timeZone?: string;
+    isLocale?: boolean;
+    constructor(tm: TimeText, units: TimestampUnit | undefined, timeType: TimeFieldType);
+    protected getLiteral(): TimeLiteralFragment;
+    protected getValue(): TimeResult;
+    getExpression(_fs: FieldSpace): ExprValue;
+    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
+    granular(): boolean;
+}
+export declare class LiteralTimestamp extends TimeLiteral {
+    elementType: string;
+    constructor(tm: TimeText, units?: TimestampUnit);
+    static parse(literalTs: string): LiteralTimestamp | undefined;
+}
+/**
+ * Granular literals imply a range. The end of that range is a constant
+ * in the generated expression, computed at compile time, to make filters faster.
+ */
+declare abstract class GranularLiteral extends TimeLiteral {
+    readonly nextLit: string;
+    constructor(tm: TimeText, units: TimestampUnit | undefined, timeType: TimeFieldType, nextLit: string);
+}
+export declare class LiteralHour extends GranularLiteral {
+    elementType: string;
+    constructor(tm: TimeText, next: string);
+    static parse(literalTs: string): LiteralHour | undefined;
+}
+declare abstract class DateBasedLiteral extends GranularLiteral {
+    constructor(tm: TimeText, units: TimestampUnit, nextLit: string);
+    getExpression(_fs: FieldSpace): ExprValue;
+}
+export declare class LiteralDay extends DateBasedLiteral {
+    elementType: string;
+    constructor(tm: TimeText, next: string);
+    static parse(literalTs: string): LiteralDay | undefined;
+}
+export declare class LiteralWeek extends DateBasedLiteral {
+    elementType: string;
+    constructor(tm: TimeText, next: string);
+    static parse(literalTs: string): LiteralWeek | undefined;
+}
+export declare class LiteralMonth extends DateBasedLiteral {
+    elementType: string;
+    constructor(tm: TimeText, next: string);
+    static parse(literalTs: string): LiteralMonth | undefined;
+}
+export declare class LiteralQuarter extends DateBasedLiteral {
+    elementType: string;
+    constructor(tm: TimeText, next: string);
+    static parse(literalTs: string): LiteralQuarter | undefined;
+}
+export declare class LiteralYear extends DateBasedLiteral {
+    elementType: string;
+    constructor(tm: TimeText, next: string);
+    static parse(literalTs: string): LiteralYear | undefined;
+}
+export {};

package/dist/lang/ast/expressions/time-literal.js

@@ -0,0 +1,316 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteralYear = exports.LiteralQuarter = exports.LiteralMonth = exports.LiteralWeek = exports.LiteralDay = exports.LiteralHour = exports.LiteralTimestamp = exports.TimeFormatError = void 0;
+const luxon_1 = require("luxon");
+const malloy_types_1 = require("../../../model/malloy_types");
+const range_1 = require("./range");
+const expr_time_1 = require("./expr-time");
+const expression_def_1 = require("../types/expression-def");
+class TimeFormatError extends Error {
+}
+exports.TimeFormatError = TimeFormatError;
+/**
+ * Finds and seperates out an optional timezone description from a time literal
+ * @param literal legal Malloy timestamp literal string
+ */
+function preParse(literal, checkTz) {
+    const text = literal.slice(1); // Drop the '@'
+    if (checkTz) {
+        const hasLocale = text.match(/\[[^\]]+]$/);
+        if (hasLocale) {
+            const tzSpec = hasLocale[0].slice(1, -1);
+            return {
+                tzSpec,
+                text: text.slice(0, -hasLocale[0].length),
+                isLocale: true,
+            };
+        }
+        const hasOffsetTz = text.match(/[+-]\d+(:\d+)?$/);
+        if (hasOffsetTz) {
+            const tzSpec = hasOffsetTz[0];
+            return { tzSpec, text: text.slice(0, -tzSpec.length) };
+        }
+    }
+    return { text };
+}
+const fYear = 'yyyy';
+const fMonth = `${fYear}-LL`;
+const fDay = `${fMonth}-dd`;
+const fHour = `${fDay} HH`;
+const fMinute = `${fHour}:mm`;
+const fTimestamp = `${fMinute}:ss`;
+/**
+ * Literals specified with an @ in Malloy all become one of these
+ */
+class TimeLiteral extends expression_def_1.ExpressionDef {
+    constructor(tm, units, timeType) {
+        super();
+        this.units = units;
+        this.timeType = timeType;
+        this.literalPart = tm.text;
+        if (tm.tzSpec) {
+            this.timeZone = tm.tzSpec;
+            if (tm.isLocale) {
+                this.isLocale = true;
+            }
+        }
+    }
+    getLiteral() {
+        return {
+            type: 'dialect',
+            function: 'timeLiteral',
+            literal: this.literalPart,
+            literalType: this.timeType,
+            timezone: this.timeZone || 'UTC',
+            tzIsLocale: this.isLocale,
+        };
+    }
+    getValue() {
+        const timeFrag = this.getLiteral();
+        const dataType = timeFrag.literalType;
+        const expressionType = 'scalar';
+        const value = [timeFrag];
+        if (this.units) {
+            return { dataType, expressionType, value, timeframe: this.units };
+        }
+        return { dataType, expressionType, value };
+    }
+    getExpression(_fs) {
+        return this.getValue();
+    }
+    apply(fs, op, left) {
+        if (this.nextLit) {
+            // We have a chance to write our own range comparison will all constants.
+            const lhs = left.getExpression(fs);
+            // MTOY todo ... only apply range on ? maybe
+            if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType)) {
+                let rangeType = 'timestamp';
+                if (lhs.dataType === 'date' && !this.timeType) {
+                    rangeType = 'date';
+                }
+                const rangeStart = this.getLiteral();
+                const rangeEnd = { ...rangeStart, literal: this.nextLit };
+                const range = new range_1.Range(new expr_time_1.ExprTime(rangeType, [rangeStart]), new expr_time_1.ExprTime(rangeType, [rangeEnd]));
+                return range.apply(fs, op, left);
+            }
+        }
+        return super.apply(fs, op, left);
+    }
+    granular() {
+        return this.nextLit !== undefined;
+    }
+}
+class LiteralTimestamp extends TimeLiteral {
+    constructor(tm, units) {
+        super(tm, units, 'timestamp');
+        this.elementType = 'literal:timestamp';
+    }
+    static parse(literalTs) {
+        // let subSecs: string | undefined;
+        let validParse = false;
+        let units = undefined;
+        let next = undefined;
+        const tm = preParse(literalTs, true);
+        literalTs = tm.text;
+        if (literalTs[10] === 'T') {
+            literalTs = literalTs.slice(0, 10) + ' ' + literalTs.slice(11);
+            tm.text = literalTs;
+        }
+        const hasSubsecs = literalTs.match(/^([^.,]+)[,.](\d+)$/);
+        if (hasSubsecs) {
+            literalTs = hasSubsecs[1];
+            // subSecs = hasSubsecs[2];
+            // TODO mtoy subsecond units not ignored
+        }
+        const tss = luxon_1.DateTime.fromFormat(literalTs, fTimestamp);
+        if (tss.isValid) {
+            validParse = true;
+        }
+        else {
+            const tsm = luxon_1.DateTime.fromFormat(literalTs, fMinute);
+            if (tsm.isValid) {
+                validParse = true;
+                tm.text = tm.text + ':00';
+                units = 'minute';
+                next = tss.plus({ minute: 1 }).toFormat(fTimestamp);
+                // MTOY todo minutes should be granular
+            }
+        }
+        if (validParse) {
+            const ts = new LiteralTimestamp(tm, units);
+            if (next) {
+                ts.nextLit = next;
+            }
+            return ts;
+        }
+        return undefined;
+    }
+}
+exports.LiteralTimestamp = LiteralTimestamp;
+/**
+ * Granular literals imply a range. The end of that range is a constant
+ * in the generated expression, computed at compile time, to make filters faster.
+ */
+class GranularLiteral extends TimeLiteral {
+    constructor(tm, units, timeType, nextLit) {
+        super(tm, units, timeType);
+        this.nextLit = nextLit;
+    }
+}
+// MTOY todo should probably put the time zone information into the luxon object
+// so that "adding an hour just before DST" works properly when a locale based
+// time is specified, but then that introduces the possibility that a locale
+// is defined differently in the DB than in Luxon ... which i don't have
+// the brain space to think about right now
+class LiteralHour extends GranularLiteral {
+    constructor(tm, next) {
+        super(tm, 'hour', 'timestamp', next);
+        this.elementType = 'literal:hour';
+    }
+    static parse(literalTs) {
+        const tm = preParse(literalTs, false);
+        let nextHour = tm.text;
+        const hourParse = luxon_1.DateTime.fromFormat(tm.text, fHour);
+        if (hourParse.isValid) {
+            tm.text = tm.text + ':00:00';
+            nextHour = hourParse.plus({ hour: 1 }).toFormat(fTimestamp);
+            return new LiteralHour(tm, nextHour);
+        }
+    }
+}
+exports.LiteralHour = LiteralHour;
+class DateBasedLiteral extends GranularLiteral {
+    constructor(tm, units, nextLit) {
+        super(tm, units, 'date', nextLit);
+    }
+    getExpression(_fs) {
+        const morphicValue = this.getValue();
+        const tsLiteral = this.getLiteral();
+        tsLiteral.literalType = 'timestamp';
+        tsLiteral.literal = tsLiteral.literal + ' 00:00:00';
+        morphicValue.morphic = { timestamp: [tsLiteral] };
+        return morphicValue;
+    }
+}
+class LiteralDay extends DateBasedLiteral {
+    constructor(tm, next) {
+        super(tm, 'day', next);
+        this.elementType = 'literal:day';
+    }
+    static parse(literalTs) {
+        const tm = preParse(literalTs, false);
+        let nextDay = tm.text;
+        const dayParse = luxon_1.DateTime.fromFormat(tm.text, fDay);
+        if (dayParse.isValid) {
+            nextDay = dayParse.plus({ day: 1 }).toFormat(fTimestamp);
+            return new LiteralDay(tm, nextDay);
+        }
+    }
+}
+exports.LiteralDay = LiteralDay;
+class LiteralWeek extends DateBasedLiteral {
+    constructor(tm, next) {
+        super(tm, 'week', next);
+        this.elementType = 'literal:week';
+    }
+    static parse(literalTs) {
+        const tm = preParse(literalTs, false);
+        let nextWeek = tm.text;
+        const datePart = tm.text.slice(0, 10);
+        const yyyymmdd = luxon_1.DateTime.fromFormat(datePart, fDay);
+        if (yyyymmdd.isValid) {
+            // wonky because luxon uses monday weeks and bigquery uses sunday weeks
+            let sunday = yyyymmdd;
+            if (yyyymmdd.weekday !== 7) {
+                sunday = yyyymmdd.startOf('week').minus({ day: 1 });
+            }
+            const next = sunday.plus({ days: 7 });
+            tm.text = sunday.toFormat(fDay);
+            nextWeek = next.toFormat(fDay);
+            return new LiteralWeek(tm, nextWeek);
+        }
+    }
+}
+exports.LiteralWeek = LiteralWeek;
+class LiteralMonth extends DateBasedLiteral {
+    constructor(tm, next) {
+        super(tm, 'month', next);
+        this.elementType = 'literal:month';
+    }
+    static parse(literalTs) {
+        const tm = preParse(literalTs, false);
+        let nextMonth = tm.text;
+        const yyyymm = luxon_1.DateTime.fromFormat(tm.text, fMonth);
+        if (yyyymm.isValid) {
+            const next = yyyymm.plus({ months: 1 });
+            tm.text = yyyymm.toFormat(fDay);
+            nextMonth = next.toFormat(fDay);
+            return new LiteralMonth(tm, nextMonth);
+        }
+    }
+}
+exports.LiteralMonth = LiteralMonth;
+class LiteralQuarter extends DateBasedLiteral {
+    constructor(tm, next) {
+        super(tm, 'quarter', next);
+        this.elementType = 'literal:quarter';
+    }
+    static parse(literalTs) {
+        const tm = preParse(literalTs, false);
+        let nextQuarter = tm.text;
+        const quarter = tm.text.match(/(^\d{4})-[qQ](\d)$/);
+        if (quarter) {
+            const qplus = Number.parseInt(quarter[2]) - 1;
+            let qstart = luxon_1.DateTime.fromFormat(quarter[1], 'yyyy');
+            if (qplus > 0) {
+                qstart = qstart.plus({ quarters: qplus });
+            }
+            const qend = qstart.plus({ quarter: 1 });
+            tm.text = qstart.toFormat(fDay);
+            nextQuarter = qend.toFormat(fDay);
+            return new LiteralQuarter(tm, nextQuarter);
+        }
+    }
+}
+exports.LiteralQuarter = LiteralQuarter;
+class LiteralYear extends DateBasedLiteral {
+    constructor(tm, next) {
+        super(tm, 'year', next);
+        this.elementType = 'literal:year';
+    }
+    static parse(literalTs) {
+        const tm = preParse(literalTs, false);
+        let next = tm.text;
+        const yyyy = luxon_1.DateTime.fromFormat(tm.text, fYear);
+        if (yyyy.isValid) {
+            const nextYear = yyyy.plus({ year: 1 });
+            tm.text = yyyy.toFormat(fDay);
+            next = nextYear.toFormat(fDay);
+            return new LiteralYear(tm, next);
+        }
+    }
+}
+exports.LiteralYear = LiteralYear;
+//# sourceMappingURL=time-literal.js.map

package/dist/lang/ast/index.d.ts

@@ -39,7 +39,7 @@ export * from './expressions/expr-sum';
 export * from './expressions/expr-time-extract';
 export * from './expressions/expr-ungroup';
 export * from './expressions/for-range';
-export * from './expressions/granular-literal';
+export * from './expressions/time-literal';
 export * from './expressions/partial-compare';
 export * from './expressions/pick-when';
 export * from './expressions/range';

package/dist/lang/ast/index.js

@@ -77,7 +77,7 @@ __exportStar(require("./expressions/expr-sum"), exports);
 __exportStar(require("./expressions/expr-time-extract"), exports);
 __exportStar(require("./expressions/expr-ungroup"), exports);
 __exportStar(require("./expressions/for-range"), exports);
-__exportStar(require("./expressions/granular-literal"), exports);
+__exportStar(require("./expressions/time-literal"), exports);
 __exportStar(require("./expressions/partial-compare"), exports);
 __exportStar(require("./expressions/pick-when"), exports);
 __exportStar(require("./expressions/range"), exports);

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

@@ -1,12 +1,10 @@
 import { AtomicFieldType, Expr, Fragment, TimeFieldType, TimestampUnit } from '../../model/malloy_types';
-import { GranularResult } from './types/granular-result';
 import { TimeResult } from './types/time-result';
 export declare function timeOffset(timeType: TimeFieldType, from: Expr, op: '+' | '-', n: Expr, timeframe: TimestampUnit): Expr;
 export declare function castTo(castType: AtomicFieldType, from: Expr, safe?: boolean): Expr;
 export declare function castTimestampToDate(from: Expr, safe?: boolean): Expr;
 export declare function castDateToTimestamp(from: Expr, safe?: boolean): Expr;
 export declare function resolution(timeframe: string): TimeFieldType;
-export declare function timeResult(t: TimeResult, tt: TimestampUnit | undefined): TimeResult | GranularResult;
-export declare function timeLiteral(literalStr: string, timeType: TimeFieldType, tz: string): Expr;
+export declare function timeResult(t: TimeResult, tt: TimestampUnit | undefined): TimeResult;
 export declare function timestampOffset(from: Fragment[], op: '+' | '-', n: Fragment[], timeframe: TimestampUnit, fromNotTimestamp?: boolean): Fragment[];
 export declare function dateOffset(from: Fragment[], op: '+' | '-', n: Fragment[], timeframe: TimestampUnit): Fragment[];

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

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dateOffset = exports.timestampOffset = exports.timeLiteral = exports.timeResult = exports.resolution = exports.castDateToTimestamp = exports.castTimestampToDate = exports.castTo = exports.timeOffset = void 0;
+exports.dateOffset = exports.timestampOffset = exports.timeResult = exports.resolution = exports.castDateToTimestamp = exports.castTimestampToDate = exports.castTo = exports.timeOffset = void 0;
 const utils_1 = require("./expressions/utils");
 function timeOffset(timeType, from, op, n, timeframe) {
     return [
@@ -91,17 +91,6 @@ function timeResult(t, tt) {
     return t;
 }
 exports.timeResult = timeResult;
-function timeLiteral(literalStr, timeType, tz) {
-    const fragment = {
-        type: 'dialect',
-        function: 'timeLiteral',
-        literal: literalStr,
-        literalType: timeType,
-        timezone: tz,
-    };
-    return [fragment];
-}
-exports.timeLiteral = timeLiteral;
 function timestampOffset(from, op, n, timeframe, fromNotTimestamp = false) {
     const useDatetime = ['week', 'month', 'quarter', 'year'].includes(timeframe);
     const add = op === '+' ? '_ADD' : '_SUB';

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

@@ -1,5 +1,8 @@
 import { Fragment } from '../../../model/malloy_types';
 import { TypeDesc } from './type-desc';
+declare type MorphicValues = Record<string, Fragment[]>;
 export interface ExprResult extends TypeDesc {
     value: Fragment[];
+    morphic?: MorphicValues;
 }
+export {};

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

@@ -1,3 +1,3 @@
-import { GranularResult } from './granular-result';
 import { ExprResult } from './expr-result';
-export declare type ExprValue = ExprResult | GranularResult;
+import { TimeResult } from './time-result';
+export declare type ExprValue = ExprResult | TimeResult;

package/dist/lang/ast/types/granular-result.js

@@ -24,10 +24,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isGranularResult = void 0;
 function isGranularResult(v) {
-    if (v.dataType !== 'date' && v.dataType !== 'timestamp') {
-        return false;
+    if (v.dataType === 'date' || v.dataType === 'timestamp') {
+        return v.timeframe !== undefined;
     }
-    return v.timeframe !== undefined;
+    return false;
 }
 exports.isGranularResult = isGranularResult;
 //# sourceMappingURL=granular-result.js.map

package/dist/lang/ast/types/time-result.d.ts

@@ -1,6 +1,6 @@
-import { TimeFieldType } from '../../../model/malloy_types';
+import { TimeFieldType, TimestampUnit } from '../../../model/malloy_types';
 import { ExprResult } from './expr-result';
 export interface TimeResult extends ExprResult {
     dataType: TimeFieldType;
-    alsoTimestamp?: true;
+    timeframe?: TimestampUnit;
 }

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

@@ -121,25 +121,26 @@ export declare class MalloyLexer extends Lexer {
     static readonly MATCH = 116;
     static readonly PERCENT = 117;
     static readonly LITERAL_TIMESTAMP = 118;
-    static readonly LITERAL_DAY = 119;
-    static readonly LITERAL_QUARTER = 120;
-    static readonly LITERAL_MONTH = 121;
-    static readonly LITERAL_WEEK = 122;
-    static readonly LITERAL_YEAR = 123;
-    static readonly IDENTIFIER = 124;
-    static readonly PERCENT_LITERAL = 125;
-    static readonly INTEGER_LITERAL = 126;
-    static readonly NUMERIC_LITERAL = 127;
-    static readonly OBJECT_NAME_LITERAL = 128;
-    static readonly BLOCK_COMMENT = 129;
-    static readonly COMMENT_TO_EOL = 130;
-    static readonly WHITE_SPACE = 131;
-    static readonly SQL_BEGIN = 132;
-    static readonly CLOSE_CODE = 133;
-    static readonly UNWATED_CHARS_TRAILING_NUMBERS = 134;
-    static readonly UNEXPECTED_CHAR = 135;
-    static readonly OPEN_CODE = 136;
-    static readonly SQL_END = 137;
+    static readonly LITERAL_HOUR = 119;
+    static readonly LITERAL_DAY = 120;
+    static readonly LITERAL_QUARTER = 121;
+    static readonly LITERAL_MONTH = 122;
+    static readonly LITERAL_WEEK = 123;
+    static readonly LITERAL_YEAR = 124;
+    static readonly IDENTIFIER = 125;
+    static readonly PERCENT_LITERAL = 126;
+    static readonly INTEGER_LITERAL = 127;
+    static readonly NUMERIC_LITERAL = 128;
+    static readonly OBJECT_NAME_LITERAL = 129;
+    static readonly BLOCK_COMMENT = 130;
+    static readonly COMMENT_TO_EOL = 131;
+    static readonly WHITE_SPACE = 132;
+    static readonly SQL_BEGIN = 133;
+    static readonly CLOSE_CODE = 134;
+    static readonly UNWATED_CHARS_TRAILING_NUMBERS = 135;
+    static readonly UNEXPECTED_CHAR = 136;
+    static readonly OPEN_CODE = 137;
+    static readonly SQL_END = 138;
     static readonly SQL_MODE = 1;
     static readonly channelNames: string[];
     static readonly modeNames: string[];