@malloydata/malloy 0.0.34-dev230523182411 → 0.0.34

package/dist/dialect/standardsql.js

@@ -29,19 +29,33 @@ const dialect_1 = require("./dialect");
 const castMap = {
     'number': 'float64',
 };
-// These are the units that "TIMESTAMP_ADD" accepts
-const timestampAddUnits = [
-    'microsecond',
-    'millisecond',
-    'second',
-    'minute',
-    'hour',
-    'day',
-];
+// These are the units that "TIMESTAMP_ADD" "TIMESTAMP_DIFF" accept
+function timestampMeasureable(units) {
+    return [
+        'microsecond',
+        'millisecond',
+        'second',
+        'minute',
+        'hour',
+        'day',
+    ].includes(units);
+}
+function dateMeasureable(units) {
+    return ['day', 'week', 'month', 'quarter', 'year'].includes(units);
+}
 const extractMap = {
     'day_of_week': 'dayofweek',
     'day_of_year': 'dayofyear',
 };
+/**
+ * Return a non UTC timezone, if one was specificed.
+ */
+function qtz(qi) {
+    const tz = qi.queryTimezone;
+    if (tz && tz !== 'UTC') {
+        return tz;
+    }
+}
 class StandardSQLDialect extends dialect_1.Dialect {
     constructor() {
         super(...arguments);
@@ -272,23 +286,27 @@ ${(0, utils_1.indent)(sql)}
     sqlNow() {
         return (0, malloy_types_1.mkExpr) `CURRENT_TIMESTAMP()`;
     }
-    sqlTrunc(sqlTime, units) {
+    sqlTrunc(qi, sqlTime, units) {
+        const tz = qtz(qi);
+        const tzAdd = tz ? `, "${tz}"` : '';
         if (sqlTime.valueType === 'date') {
-            if ((0, malloy_types_1.isDateUnit)(units)) {
+            if (dateMeasureable(units)) {
                 return (0, malloy_types_1.mkExpr) `DATE_TRUNC(${sqlTime.value},${units})`;
             }
-            return (0, malloy_types_1.mkExpr) `TIMESTAMP(${sqlTime.value})`;
+            return (0, malloy_types_1.mkExpr) `TIMESTAMP(${sqlTime.value}${tzAdd})`;
         }
-        return (0, malloy_types_1.mkExpr) `TIMESTAMP_TRUNC(${sqlTime.value},${units})`;
+        return (0, malloy_types_1.mkExpr) `TIMESTAMP_TRUNC(${sqlTime.value},${units}${tzAdd})`;
     }
-    sqlExtract(expr, units) {
+    sqlExtract(qi, expr, units) {
         const extractTo = extractMap[units] || units;
-        return (0, malloy_types_1.mkExpr) `EXTRACT(${extractTo} FROM ${expr.value})`;
+        const tz = expr.valueType === 'timestamp' && qtz(qi);
+        const tzAdd = tz ? ` AT TIME ZONE '${tz}'` : '';
+        return (0, malloy_types_1.mkExpr) `EXTRACT(${extractTo} FROM ${expr.value}${tzAdd})`;
     }
     sqlAlterTime(op, expr, n, timeframe) {
         let theTime = expr.value;
         let computeType = expr.valueType;
-        if (timeframe !== 'day' && timestampAddUnits.includes(timeframe)) {
+        if (timeframe !== 'day' && timestampMeasureable(timeframe)) {
             // The units must be done in timestamp, no matter the input type
             computeType = 'timestamp';
             if (expr.valueType !== 'timestamp') {
@@ -301,21 +319,25 @@ ${(0, utils_1.indent)(sql)}
         }
         const funcName = computeType.toUpperCase() + (op === '+' ? '_ADD' : '_SUB');
         const newTime = (0, malloy_types_1.mkExpr) `${funcName}(${theTime}, INTERVAL ${n} ${timeframe})`;
-        return computeType === 'datetime' ? (0, malloy_types_1.mkExpr) `TIMESTAMP(${newTime})` : newTime;
+        if (computeType === expr.valueType) {
+            return newTime;
+        }
+        return (0, malloy_types_1.mkExpr) `${expr.valueType.toUpperCase()}(${newTime})`;
     }
     ignoreInProject(fieldName) {
         return fieldName === '_PARTITIONTIME';
     }
-    sqlCast(cast) {
+    sqlCast(qi, cast) {
+        const op = `${cast.srcType}::${cast.dstType}`;
+        const tz = qtz(qi);
+        if (op === 'timestamp::date' && tz) {
+            return (0, malloy_types_1.mkExpr) `DATE(${cast.expr},'${tz}')`;
+        }
+        if (op === 'date::timestamp' && tz) {
+            return (0, malloy_types_1.mkExpr) `TIMESTAMP(${cast.expr}, '${tz}')`;
+        }
         if (cast.srcType !== cast.dstType) {
             const dstType = castMap[cast.dstType] || cast.dstType;
-            // This just makes the code look a little prettier ...
-            if (!cast.safe && cast.srcType && (0, malloy_types_1.isTimeFieldType)(cast.srcType)) {
-                if (dstType === 'date') {
-                    return (0, malloy_types_1.mkExpr) `DATE(${cast.expr})`;
-                }
-                return (0, malloy_types_1.mkExpr) `TIMESTAMP(${cast.expr})`;
-            }
             const castFunc = cast.safe ? 'SAFE_CAST' : 'CAST';
             return (0, malloy_types_1.mkExpr) `${castFunc}(${cast.expr}  AS ${dstType})`;
         }
@@ -324,39 +346,53 @@ ${(0, utils_1.indent)(sql)}
     sqlRegexpMatch(expr, regexp) {
         return (0, malloy_types_1.mkExpr) `REGEXP_CONTAINS(${expr}, r${regexp})`;
     }
-    sqlLiteralTime(timeString, type, timezone) {
+    sqlLiteralTime(qi, timeString, type, timezone) {
         if (type === 'date') {
             return `DATE('${timeString}')`;
         }
         else if (type === 'timestamp') {
-            return `TIMESTAMP('${timeString}', '${timezone}')`;
+            let timestampArgs = `'${timeString}'`;
+            const tz = timezone || qtz(qi);
+            if (tz && tz !== 'UTC') {
+                timestampArgs += `,'${tz}'`;
+            }
+            return `TIMESTAMP(${timestampArgs})`;
         }
         else {
-            throw new Error(`Unknown Liternal time format ${type}`);
+            throw new Error(`Unsupported Literal time format ${type}`);
         }
     }
     sqlMeasureTime(from, to, units) {
+        const measureMap = {
+            microsecond: { use: 'microsecond', ratio: 1 },
+            millisecond: { use: 'microsecond', ratio: 1000 },
+            second: { use: 'millisecond', ratio: 1000 },
+            minute: { use: 'second', ratio: 60 },
+            hour: { use: 'minute', ratio: 60 },
+            day: { use: 'hour', ratio: 24 },
+            week: { use: 'day', ratio: 7 },
+        };
         let lVal = from.value;
         let rVal = to.value;
-        let diffUsing = 'TIMESTAMP_DIFF';
-        if (units === 'second' || units === 'minute' || units === 'hour') {
-            if (from.valueType !== 'timestamp') {
-                lVal = (0, malloy_types_1.mkExpr) `TIMESTAMP(${lVal})`;
+        if (measureMap[units]) {
+            const { use: measureIn, ratio } = measureMap[units];
+            if (!timestampMeasureable(measureIn)) {
+                throw new Error(`Measure in '${measureIn} not implemented`);
             }
-            if (to.valueType !== 'timestamp') {
-                rVal = (0, malloy_types_1.mkExpr) `TIMESTAMP(${rVal})`;
+            if (from.valueType !== to.valueType) {
+                throw new Error("Can't measure difference between different types");
             }
-        }
-        else {
-            diffUsing = 'DATE_DIFF';
-            if (from.valueType !== 'date') {
-                lVal = (0, malloy_types_1.mkExpr) `DATE(${lVal})`;
+            if (from.valueType === 'date') {
+                lVal = (0, malloy_types_1.mkExpr) `TIMESTAMP(${lVal})`;
+                rVal = (0, malloy_types_1.mkExpr) `TIMESTAMP(${rVal})`;
             }
-            if (to.valueType !== 'date') {
-                rVal = (0, malloy_types_1.mkExpr) `DATE(${rVal})`;
+            let measured = (0, malloy_types_1.mkExpr) `TIMESTAMP_DIFF(${rVal},${lVal},${measureIn})`;
+            if (ratio !== 1) {
+                measured = (0, malloy_types_1.mkExpr) `FLOOR(${measured}/${ratio.toString()}.0)`;
             }
+            return measured;
         }
-        return (0, malloy_types_1.mkExpr) `${diffUsing}(${rVal}, ${lVal}, ${units})`;
+        throw new Error(`Measure '${units} not implemented`);
     }
     sqlSampleTable(tableSQL, sample) {
         if (sample !== undefined) {

package/dist/lang/ast/elements/refined-source.js

@@ -37,6 +37,7 @@ const primary_key_1 = require("../source-properties/primary-key");
 const renames_1 = require("../source-properties/renames");
 const turtles_1 = require("../source-properties/turtles");
 const source_1 = require("./source");
+const timezone_statement_1 = require("../source-properties/timezone-statement");
 /**
  * A Source made from a source reference and a set of refinements
  */
@@ -55,6 +56,7 @@ class RefinedSource extends source_1.Source {
         let fieldListEdit;
         const fields = [];
         const filters = [];
+        let newTimezone;
         for (const el of this.refinement.list) {
             const errTo = el;
             if (el instanceof primary_key_1.PrimaryKey) {
@@ -80,6 +82,9 @@ class RefinedSource extends source_1.Source {
             else if (el instanceof filters_1.Filter) {
                 filters.push(el);
             }
+            else if (el instanceof timezone_statement_1.TimezoneStatement) {
+                newTimezone = el.tz;
+            }
             else {
                 errTo.log(`Unexpected explore property: '${errTo.elementType}'`);
             }
@@ -89,6 +94,9 @@ class RefinedSource extends source_1.Source {
             from.primaryKey = primaryKey.field.name;
         }
         const fs = refined_space_1.RefinedSpace.filteredFrom(from, fieldListEdit);
+        if (newTimezone) {
+            fs.setTimezone(newTimezone);
+        }
         fs.addField(...fields);
         if (pList) {
             fs.addParameters(pList);

package/dist/lang/ast/executors/reduce-executor.js

@@ -36,6 +36,7 @@ const top_1 = require("../query-properties/top");
 const nests_1 = require("../query-properties/nests");
 const nest_1 = require("../query-properties/nest");
 const query_spaces_1 = require("../field-space/query-spaces");
+const timezone_statement_1 = require("../source-properties/timezone-statement");
 class ReduceExecutor {
     constructor(baseFS) {
         this.filters = [];
@@ -94,6 +95,9 @@ class ReduceExecutor {
                 this.inputFS.extendSource(qel);
             }
         }
+        else if (qp instanceof timezone_statement_1.TimezoneStatement) {
+            this.resultFS.setTimezone(qp.tz);
+        }
     }
     refineFrom(from, to) {
         if (from && from.type !== 'index') {

package/dist/lang/ast/expressions/expr-cast.js

@@ -43,7 +43,7 @@ class ExprCast extends expression_def_1.ExpressionDef {
         return {
             dataType: this.castType,
             expressionType: expr.expressionType,
-            value: (0, utils_1.compressExpr)((0, time_utils_1.castTo)(this.castType, expr.value, this.safe)),
+            value: (0, utils_1.compressExpr)((0, time_utils_1.castTo)(this.castType, expr.value, expr.dataType, this.safe)),
         };
     }
 }

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

@@ -2,6 +2,7 @@ import { TimestampUnit } from '../../../model/malloy_types';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
+import { Range } from './range';
 /**
  * GranularTime is a moment in time which ALSO has a "granularity"
  * commonly this are created by applying ".datePart" to an expression
@@ -19,6 +20,5 @@ export declare class ExprGranularTime extends ExpressionDef {
     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;
+    protected getRange(fs: FieldSpace): Range;
 }

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

@@ -74,13 +74,7 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
         return (0, ast_utils_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);
+        return this.getRange(fs).apply(fs, op, left);
         /*
           write tests for each of these cases ....
     
@@ -97,20 +91,17 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
     
         */
     }
-    timestampRange(fs, op, expr) {
-        const begin = this.getExpression(fs);
-        const beginTime = expr_time_1.ExprTime.fromValue('timestamp', begin);
-        const endTime = new expr_time_1.ExprTime('timestamp', (0, time_utils_1.timeOffset)('timestamp', begin.value, '+', (0, malloy_types_1.mkExpr) `1`, this.units), begin.expressionType);
-        const range = new range_1.Range(beginTime, endTime);
-        return range.apply(fs, op, expr);
-    }
-    dateRange(fs, op, expr) {
+    getRange(fs) {
         const begin = this.getExpression(fs);
-        const beginTime = new expr_time_1.ExprTime('date', begin.value, begin.expressionType);
+        if (begin.dataType === 'timestamp') {
+            const beginTS = expr_time_1.ExprTime.fromValue('timestamp', begin);
+            const endTS = new expr_time_1.ExprTime('timestamp', (0, time_utils_1.timeOffset)('timestamp', begin.value, '+', (0, malloy_types_1.mkExpr) `1`, this.units), begin.expressionType);
+            return new range_1.Range(beginTS, endTS);
+        }
+        const beginDate = new expr_time_1.ExprTime('date', begin.value, begin.expressionType);
         const endAt = (0, time_utils_1.timeOffset)('date', begin.value, '+', ['1'], this.units);
-        const end = new expr_time_1.ExprTime('date', endAt, begin.expressionType);
-        const range = new range_1.Range(beginTime, end);
-        return range.apply(fs, op, expr);
+        const endDate = new expr_time_1.ExprTime('date', endAt, begin.expressionType);
+        return new range_1.Range(beginDate, endDate);
     }
 }
 exports.ExprGranularTime = ExprGranularTime;

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

@@ -52,8 +52,8 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
             }
             const from = this.args[0];
             if (from instanceof range_1.Range) {
-                const first = from.first.getExpression(fs);
-                const last = from.last.getExpression(fs);
+                let first = from.first.getExpression(fs);
+                let 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, ast_utils_1.errorFor)(`${extractTo} bad type ${first.dataType}`);
@@ -62,6 +62,33 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                     from.last.log(`Cannot extract ${extractTo} from '${last.dataType}'`);
                     return (0, ast_utils_1.errorFor)(`${extractTo} bad type ${last.dataType}`);
                 }
+                let valueType = first.dataType;
+                if (first.dataType !== last.dataType) {
+                    let cannotMeasure = true;
+                    valueType = 'timestamp';
+                    if (first.dataType === 'date') {
+                        const newFirst = (0, expression_def_1.getMorphicValue)(first, 'timestamp');
+                        if (newFirst) {
+                            first = newFirst;
+                            cannotMeasure = false;
+                        }
+                    }
+                    else {
+                        const newLast = (0, expression_def_1.getMorphicValue)(last, 'timestamp');
+                        if (newLast) {
+                            last = newLast;
+                            cannotMeasure = false;
+                        }
+                    }
+                    if (cannotMeasure) {
+                        from.first.log(`Cannot measure from ${first.dataType} to ${last.dataType}`);
+                        return (0, ast_utils_1.errorFor)(`${extractTo} range mismatch`);
+                    }
+                }
+                if (['week', 'month', 'quarter', 'year'].includes(extractTo)) {
+                    this.log(`Cannot measure interval using '${extractTo}'`);
+                    return (0, ast_utils_1.errorFor)(`${extractTo} civil extraction`);
+                }
                 if (!(0, malloy_types_1.isTimestampUnit)(extractTo)) {
                     this.log(`Cannot extract ${extractTo} from a range`);
                     return (0, ast_utils_1.errorFor)(`${extractTo} bad extraction`);
@@ -74,8 +101,8 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                             type: 'dialect',
                             function: 'timeDiff',
                             units: extractTo,
-                            left: { valueType: first.dataType, value: first.value },
-                            right: { valueType: last.dataType, value: last.value },
+                            left: { valueType, value: first.value },
+                            right: { valueType, value: last.value },
                         },
                     ],
                 };

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

@@ -8,7 +8,6 @@ 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
@@ -19,12 +18,11 @@ declare abstract class TimeLiteral extends ExpressionDef {
     literalPart: string;
     nextLit?: string;
     timeZone?: string;
-    isLocale?: boolean;
     constructor(tm: TimeText, units: TimestampUnit | undefined, timeType: TimeFieldType);
-    protected getLiteral(): TimeLiteralFragment;
-    protected getValue(): TimeResult;
+    protected makeLiteral(val: string, typ: TimeFieldType): TimeLiteralFragment;
+    protected makeValue(val: string, dataType: TimeFieldType): TimeResult;
     getExpression(_fs: FieldSpace): ExprValue;
-    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
+    getNext(): ExprValue | undefined;
     granular(): boolean;
 }
 export declare class LiteralTimestamp extends TimeLiteral {
@@ -36,18 +34,26 @@ export declare class LiteralTimestamp extends TimeLiteral {
  * 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 {
+declare class GranularLiteral extends TimeLiteral {
     readonly nextLit: string;
+    elementType: string;
     constructor(tm: TimeText, units: TimestampUnit | undefined, timeType: TimeFieldType, nextLit: string);
+    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
 }
 export declare class LiteralHour extends GranularLiteral {
     elementType: string;
     constructor(tm: TimeText, next: string);
     static parse(literalTs: string): LiteralHour | undefined;
 }
+/**
+ * DateBasedLiteral and all of the children are special because a literal
+ * of this type (e.g. @2003) can be used in expressions with Date or
+ * Timestamp data, and the correct literal will be used based on context.
+ */
 declare abstract class DateBasedLiteral extends GranularLiteral {
     constructor(tm: TimeText, units: TimestampUnit, nextLit: string);
     getExpression(_fs: FieldSpace): ExprValue;
+    getNext(): ExprValue | undefined;
 }
 export declare class LiteralDay extends DateBasedLiteral {
     elementType: string;

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

@@ -44,14 +44,8 @@ function preParse(literal, checkTz) {
             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 };
 }
@@ -72,24 +66,22 @@ class TimeLiteral extends expression_def_1.ExpressionDef {
         this.literalPart = tm.text;
         if (tm.tzSpec) {
             this.timeZone = tm.tzSpec;
-            if (tm.isLocale) {
-                this.isLocale = true;
-            }
         }
     }
-    getLiteral() {
-        return {
+    makeLiteral(val, typ) {
+        const timeFrag = {
             type: 'dialect',
             function: 'timeLiteral',
-            literal: this.literalPart,
-            literalType: this.timeType,
-            timezone: this.timeZone || 'UTC',
-            tzIsLocale: this.isLocale,
+            literal: val,
+            literalType: typ,
         };
+        if (this.timeZone) {
+            timeFrag.timezone = this.timeZone;
+        }
+        return timeFrag;
     }
-    getValue() {
-        const timeFrag = this.getLiteral();
-        const dataType = timeFrag.literalType;
+    makeValue(val, dataType) {
+        const timeFrag = this.makeLiteral(val, dataType);
         const expressionType = 'scalar';
         const value = [timeFrag];
         if (this.units) {
@@ -98,25 +90,12 @@ class TimeLiteral extends expression_def_1.ExpressionDef {
         return { dataType, expressionType, value };
     }
     getExpression(_fs) {
-        return this.getValue();
+        return this.makeValue(this.literalPart, this.timeType);
     }
-    apply(fs, op, left) {
+    getNext() {
         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 this.makeValue(this.nextLit, this.timeType);
         }
-        return super.apply(fs, op, left);
     }
     granular() {
         return this.nextLit !== undefined;
@@ -129,9 +108,7 @@ class LiteralTimestamp extends TimeLiteral {
     }
     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') {
@@ -142,29 +119,22 @@ class LiteralTimestamp extends TimeLiteral {
         if (hasSubsecs) {
             literalTs = hasSubsecs[1];
             // subSecs = hasSubsecs[2];
-            // TODO mtoy subsecond units not ignored
+            // mtoy TODO subsecond units not ignored
         }
-        const tss = luxon_1.DateTime.fromFormat(literalTs, fTimestamp);
-        if (tss.isValid) {
-            validParse = true;
+        let ts = luxon_1.DateTime.fromFormat(literalTs, fTimestamp);
+        if (ts.isValid) {
+            return new LiteralTimestamp(tm, units);
         }
         else {
-            const tsm = luxon_1.DateTime.fromFormat(literalTs, fMinute);
-            if (tsm.isValid) {
-                validParse = true;
+            ts = luxon_1.DateTime.fromFormat(literalTs, fMinute);
+            if (ts.isValid) {
                 tm.text = tm.text + ':00';
                 units = 'minute';
-                next = tss.plus({ minute: 1 }).toFormat(fTimestamp);
-                // MTOY todo minutes should be granular
+                const next = ts.plus({ minute: 1 }).toFormat(fTimestamp);
+                const astMinute = new GranularLiteral(tm, units, 'timestamp', next);
+                return astMinute;
             }
         }
-        if (validParse) {
-            const ts = new LiteralTimestamp(tm, units);
-            if (next) {
-                ts.nextLit = next;
-            }
-            return ts;
-        }
         return undefined;
     }
 }
@@ -177,6 +147,32 @@ class GranularLiteral extends TimeLiteral {
     constructor(tm, units, timeType, nextLit) {
         super(tm, units, timeType);
         this.nextLit = nextLit;
+        this.elementType = 'granularTimeLiteral';
+    }
+    apply(fs, op, left) {
+        // We have a chance to write our own range comparison will all constants.
+        let rangeStart = this.getExpression(fs);
+        let rangeEnd = this.getNext();
+        if (rangeEnd) {
+            const testValue = left.getExpression(fs);
+            if (testValue.dataType === 'timestamp') {
+                const newStart = (0, expression_def_1.getMorphicValue)(rangeStart, 'timestamp');
+                const newEnd = (0, expression_def_1.getMorphicValue)(rangeEnd, 'timestamp');
+                if (newStart && newEnd) {
+                    rangeStart = newStart;
+                    rangeEnd = newEnd;
+                }
+                else {
+                    return super.apply(fs, op, left);
+                }
+            }
+            if ((0, malloy_types_1.isTimeFieldType)(testValue.dataType)) {
+                const rangeType = testValue.dataType;
+                const range = new range_1.Range(new expr_time_1.ExprTime(rangeType, rangeStart.value), new expr_time_1.ExprTime(rangeType, rangeEnd.value));
+                return range.apply(fs, op, left);
+            }
+        }
+        return super.apply(fs, op, left);
     }
 }
 // MTOY todo should probably put the time zone information into the luxon object
@@ -201,17 +197,28 @@ class LiteralHour extends GranularLiteral {
     }
 }
 exports.LiteralHour = LiteralHour;
+/**
+ * DateBasedLiteral and all of the children are special because a literal
+ * of this type (e.g. @2003) can be used in expressions with Date or
+ * Timestamp data, and the correct literal will be used based on context.
+ */
 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;
+        const dateValue = this.makeValue(this.literalPart, 'date');
+        const timestamp = [
+            this.makeLiteral(`${this.literalPart} 00:00:00`, 'timestamp'),
+        ];
+        return { ...dateValue, morphic: { timestamp } };
+    }
+    getNext() {
+        const dateValue = this.makeValue(this.nextLit, 'date');
+        const timestamp = [
+            this.makeLiteral(`${this.nextLit} 00:00:00`, 'timestamp'),
+        ];
+        return { ...dateValue, morphic: { timestamp } };
     }
 }
 class LiteralDay extends DateBasedLiteral {
@@ -224,7 +231,7 @@ class LiteralDay extends DateBasedLiteral {
         let nextDay = tm.text;
         const dayParse = luxon_1.DateTime.fromFormat(tm.text, fDay);
         if (dayParse.isValid) {
-            nextDay = dayParse.plus({ day: 1 }).toFormat(fTimestamp);
+            nextDay = dayParse.plus({ day: 1 }).toFormat(fDay);
             return new LiteralDay(tm, nextDay);
         }
     }
@@ -241,15 +248,15 @@ class LiteralWeek extends DateBasedLiteral {
         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 luxonDay = yyyymmdd.weekday;
+            if (luxonDay === 7) {
+                // Weeks must start on a sunday. If you don't know when the
+                // week starts use @YYYY-MM-DD.week to truncate
+                const next = yyyymmdd.plus({ days: 7 });
+                tm.text = yyyymmdd.toFormat(fDay);
+                nextWeek = next.toFormat(fDay);
+                return new LiteralWeek(tm, nextWeek);
             }
-            const next = sunday.plus({ days: 7 });
-            tm.text = sunday.toFormat(fDay);
-            nextWeek = next.toFormat(fDay);
-            return new LiteralWeek(tm, nextWeek);
         }
     }
 }

package/dist/lang/ast/field-space/dynamic-space.d.ts

@@ -11,6 +11,7 @@ export declare abstract class DynamicSpace extends StaticSpace {
     outputFS?: FieldSpace;
     completions: (() => void)[];
     private complete;
+    protected newTimezone?: string;
     constructor(extending: SourceSpec);
     whenComplete(finalizeStep: () => void): void;
     isComplete(): void;
@@ -18,5 +19,6 @@ export declare abstract class DynamicSpace extends StaticSpace {
     addParameters(params: HasParameter[]): DynamicSpace;
     newEntry(name: string, astEl: MalloyElement, entry: SpaceEntry): void;
     addFieldDef(fd: model.FieldDef): void;
+    setTimezone(tz: string): void;
     structDef(): model.StructDef;
 }