@malloydata/malloy 0.0.245 → 0.0.246-dev250320220920

package/dist/dialect/pg_impl.js

@@ -52,7 +52,7 @@ class PostgresBase extends dialect_1.Dialect {
             }
         }
         const extracted = `EXTRACT(${units} FROM ${extractFrom})`;
-        return from.units === 'day_of_week' ? `mod(${extracted}+1,7)` : extracted;
+        return from.units === 'day_of_week' ? `(${extracted}+1)` : extracted;
     }
     sqlCast(qi, cast) {
         const expr = cast.e.sql || '';

package/dist/dialect/postgres/postgres.js

@@ -257,7 +257,7 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
             timeframe = 'day';
             n = `${n}*7`;
         }
-        const interval = `make_interval(${pgMakeIntervalMap[timeframe]}=>${n})`;
+        const interval = `make_interval(${pgMakeIntervalMap[timeframe]}=>(${n})::integer)`;
         return `(${df.kids.base.sql})${df.op}${interval}`;
     }
     sqlCast(qi, cast) {

package/dist/dialect/snowflake/snowflake.js

@@ -270,8 +270,10 @@ ${(0, utils_1.indent)(sql)}
         return `EXTRACT(${extractUnits} FROM ${extractFrom})`;
     }
     sqlAlterTimeExpr(df) {
-        const interval = `INTERVAL '${df.kids.delta.sql} ${df.units}'`;
-        return `(${df.kids.base.sql})${df.op}${interval}`;
+        var _a;
+        const add = ((_a = df.typeDef) === null || _a === void 0 ? void 0 : _a.type) === 'date' ? 'DATEADD' : 'TIMESTAMPADD';
+        const n = df.op === '+' ? df.kids.delta.sql : `-(${df.kids.delta.sql})`;
+        return `${add}(${df.units},${n},${df.kids.base.sql})`;
     }
     atTz(sqlExpr, tz) {
         if (tz !== undefined) {

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

@@ -21,6 +21,7 @@ class ExprFilterExpression extends expression_def_1.ExpressionDef {
         return this.loggedErrorExpr('filter-expression-type', 'Filter expression illegal here');
     }
     apply(fs, op, left, _warnOnComplexTree = false) {
+        var _a;
         if (op === '~' || op === '!~') {
             const matchExpr = left.getExpression(fs);
             if (matchExpr.type === 'error') {
@@ -35,6 +36,9 @@ class ExprFilterExpression extends expression_def_1.ExpressionDef {
                     fParse = malloy_filter_1.NumberFilterExpression.parse(this.filterText);
                     break;
                 case 'boolean':
+                    if ((_a = fs.dialectObj()) === null || _a === void 0 ? void 0 : _a.booleanAsNumbers) {
+                        return this.loggedErrorExpr('filter-expression-type', 'Boolean filters not supported on this connection type');
+                    }
                     fParse = malloy_filter_1.BooleanFilterExpression.parse(this.filterText);
                     break;
                 case 'date':

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

@@ -36,7 +36,7 @@ class ExprNow extends expression_def_1.ExpressionDef {
             expressionType: 'scalar',
             // `now` is considered to be a constant, at least in the dialects we support today
             evalSpace: 'constant',
-            value: { node: 'now' },
+            value: { node: 'now', typeDef: { type: 'timestamp' } },
             compositeFieldUsage: (0, composite_source_utils_1.emptyCompositeFieldUsage)(),
         };
     }

package/dist/lang/test/parse-expects.js

@@ -197,7 +197,8 @@ expect.extend({
         if (!badRefs.pass) {
             return badRefs;
         }
-        const rcvExpr = (0, expr_to_str_1.exprToStr)(bx.generated().value, undefined);
+        const toExpr = bx.generated().value;
+        const rcvExpr = (0, expr_to_str_1.exprToStr)(toExpr, undefined);
         const pass = this.equals(rcvExpr, expr);
         const msg = pass ? `Matched: ${rcvExpr}` : this.utils.diff(expr, rcvExpr);
         return { pass, message: () => `${msg}` };

package/dist/model/filter_compilers.d.ts

@@ -1,9 +1,9 @@
-import type { BooleanClause, ClauseBase, NumberClause, StringClause, TemporalClause } from '@malloydata/malloy-filter';
+import type { BooleanFilter, FilterExpression, NumberFilter, StringFilter, TemporalFilter } from '@malloydata/malloy-filter';
 import type { Dialect } from '../dialect';
 export declare const FilterCompilers: {
-    compile(t: string, c: ClauseBase, x: string, d: Dialect): string;
-    numberCompile(nc: NumberClause, x: string, d: Dialect): string;
-    booleanCompile(bc: BooleanClause, x: string, _d: Dialect): string;
-    temporalCompile(tc: TemporalClause, x: string, d: Dialect): string;
-    stringCompile(sc: StringClause, x: string, d: Dialect): string;
+    compile(t: string, c: FilterExpression, x: string, d: Dialect): string;
+    numberCompile(nc: NumberFilter, x: string, d: Dialect): string;
+    booleanCompile(bc: BooleanFilter, x: string, _d: Dialect): string;
+    stringCompile(sc: StringFilter, x: string, d: Dialect): string;
+    temporalCompile(tc: TemporalFilter, x: string, d: Dialect): string;
 };

package/dist/model/filter_compilers.js

@@ -8,6 +8,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilterCompilers = void 0;
 const malloy_filter_1 = require("@malloydata/malloy-filter");
+const filter_temporal_compiler_1 = require("./filter_temporal_compiler");
 function escapeForLike(v) {
     return v.replace(/([%_\\])/g, '\\$1');
 }
@@ -36,16 +37,16 @@ function unlike(disLiked, x) {
  */
 exports.FilterCompilers = {
     compile(t, c, x, d) {
-        if (t === 'string' && (0, malloy_filter_1.isStringClause)(c)) {
+        if (t === 'string' && (0, malloy_filter_1.isStringFilter)(c)) {
             return exports.FilterCompilers.stringCompile(c, x, d);
         }
-        else if (t === 'number' && (0, malloy_filter_1.isNumberClause)(c)) {
+        else if (t === 'number' && (0, malloy_filter_1.isNumberFilter)(c)) {
             return exports.FilterCompilers.numberCompile(c, x, d);
         }
-        else if (t === 'boolean' && (0, malloy_filter_1.isBooleanClause)(c)) {
+        else if (t === 'boolean' && (0, malloy_filter_1.isBooleanFilter)(c)) {
             return exports.FilterCompilers.booleanCompile(c, x, d);
         }
-        else if ((t === 'date' || t === 'timestamp') && (0, malloy_filter_1.isTemporalClause)(c)) {
+        else if ((t === 'date' || t === 'timestamp') && (0, malloy_filter_1.isTemporalFilter)(c)) {
             return exports.FilterCompilers.temporalCompile(c, x, d);
         }
         throw new Error('INTERNAL ERROR: No filter compiler for ' + t);
@@ -93,7 +94,7 @@ exports.FilterCompilers = {
             case 'or':
                 return nc.members
                     .map(m => exports.FilterCompilers.numberCompile(m, x, d))
-                    .join(` ${nc.operator.toUpperCase()}`);
+                    .join(` ${nc.operator.toUpperCase()} `);
         }
     },
     booleanCompile(bc, x, _d) {
@@ -108,10 +109,6 @@ exports.FilterCompilers = {
                 return x;
         }
     },
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    temporalCompile(tc, x, d) {
-        return 'false';
-    },
     stringCompile(sc, x, d) {
         switch (sc.operator) {
             case 'null':
@@ -171,6 +168,8 @@ exports.FilterCompilers = {
                 /*
                  * Basic formula over all members
                  * ALL INCLUDED THINGS OR TOGETHER AND ALL EXCLUDED THINGS ANDED TOGETHER
+                 *
+                 * mtoy todo write some tests to see if AND clauses are includes or excludes
                  */
                 const includes = [];
                 const excludes = [];
@@ -243,5 +242,10 @@ exports.FilterCompilers = {
             }
         }
     },
+    // mtoy todo figure out what to do about dates
+    temporalCompile(tc, x, d) {
+        const c = new filter_temporal_compiler_1.TemporalFilterCompiler(x, d);
+        return c.compile(tc);
+    },
 };
 //# sourceMappingURL=filter_compilers.js.map

package/dist/model/filter_temporal_compiler.d.ts

@@ -0,0 +1,28 @@
+import type { TemporalFilter } from '@malloydata/malloy-filter';
+import type { Dialect } from '../dialect';
+/**
+ * I felt like there was enough "helpful functions needed to make everything
+ * work, all of which need to know the dialect", to justify making a class
+ * for this. Maybe this should just be a set of functions which take
+ * a dialect as an argument?
+ */
+export declare class TemporalFilterCompiler {
+    readonly expr: string;
+    readonly timetype: 'timestamp' | 'date';
+    readonly d: Dialect;
+    constructor(expr: string, dialect: Dialect, timetype?: 'timestamp' | 'date');
+    compile(tc: TemporalFilter): string;
+    private expandLiteral;
+    private literalNode;
+    private nowExpr;
+    private n;
+    private delta;
+    private dayofWeek;
+    private nowDot;
+    private thisUnit;
+    private lastUnit;
+    private nextUnit;
+    mod7(n: string): string;
+    private moment;
+    private isIn;
+}

package/dist/model/filter_temporal_compiler.js

@@ -0,0 +1,325 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemporalFilterCompiler = void 0;
+const malloy_types_1 = require("./malloy_types");
+const luxon_1 = require("luxon");
+const fYear = 'yyyy';
+const fMonth = `${fYear}-LL`;
+const fDay = `${fMonth}-dd`;
+const fHour = `${fDay} HH`;
+const fMinute = `${fHour}:mm`;
+const fTimestamp = `${fMinute}:ss`;
+/**
+ * I felt like there was enough "helpful functions needed to make everything
+ * work, all of which need to know the dialect", to justify making a class
+ * for this. Maybe this should just be a set of functions which take
+ * a dialect as an argument?
+ */
+class TemporalFilterCompiler {
+    constructor(expr, dialect, timetype = 'timestamp') {
+        this.expr = expr;
+        this.timetype = timetype;
+        this.d = dialect;
+    }
+    compile(tc) {
+        const x = this.expr;
+        switch (tc.operator) {
+            case 'after':
+                return `${x} ${tc.not ? '<' : '>='} ${this.moment(tc.after).end}`;
+            case 'before':
+                return `${x} ${tc.not ? '>=' : '<'} ${this.moment(tc.before).begin}`;
+            case 'in': {
+                // mtoy todo in now
+                const m = this.moment(tc.in);
+                return this.isIn(tc.not, m.begin.sql, m.end);
+            }
+            case 'for': {
+                const start = this.moment(tc.begin);
+                const end = this.delta(start.begin, '+', tc.n, tc.units);
+                return this.isIn(tc.not, start.begin.sql, end.sql);
+            }
+            case 'in_last': {
+                // last N units means "N - 1 UNITS AGO FOR N UNITS"
+                const back = Number(tc.n) - 1;
+                const thisUnit = this.nowDot(tc.units);
+                const start = back > 0
+                    ? this.delta(thisUnit, '-', back.toString(), tc.units)
+                    : thisUnit;
+                const end = this.delta(thisUnit, '+', '1', tc.units);
+                return this.isIn(tc.not, start.sql, end.sql);
+            }
+            case 'to': {
+                const firstMoment = this.moment(tc.fromMoment);
+                const lastMoment = this.moment(tc.toMoment);
+                return this.isIn(tc.not, firstMoment.begin.sql, lastMoment.end);
+            }
+            case 'last': {
+                const thisUnit = this.nowDot(tc.units);
+                const start = this.delta(thisUnit, '-', tc.n, tc.units);
+                return this.isIn(tc.not, start.sql, thisUnit.sql);
+            }
+            case 'next': {
+                const thisUnit = this.nowDot(tc.units);
+                const start = this.delta(thisUnit, '+', '1', tc.units);
+                const end = this.delta(thisUnit, '+', (Number(tc.n) + 1).toString(), tc.units);
+                return this.isIn(tc.not, start.sql, end.sql);
+            }
+            case 'null':
+                return tc.not ? `${x} IS NOT NULL` : `${x} IS NULL`;
+            case '()': {
+                const wrapped = '(' + this.compile(tc.expr) + ')';
+                return tc.not ? `NOT ${wrapped}` : wrapped;
+            }
+            case 'and':
+            case 'or':
+                return tc.members
+                    .map(m => this.compile(m))
+                    .join(` ${tc.operator.toUpperCase()} `);
+        }
+    }
+    expandLiteral(tl) {
+        let literal = tl.literal;
+        switch (tl.units) {
+            case 'year': {
+                const y = luxon_1.DateTime.fromFormat(literal, fYear);
+                const begin = this.literalNode(y.toFormat(fTimestamp));
+                const next = y.plus({ year: 1 });
+                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
+            }
+            case 'month': {
+                const yyyymm = luxon_1.DateTime.fromFormat(literal, fMonth);
+                const begin = this.literalNode(yyyymm.toFormat(fTimestamp));
+                const next = yyyymm.plus({ month: 1 });
+                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
+            }
+            case 'day': {
+                const yyyymmdd = luxon_1.DateTime.fromFormat(literal, fDay);
+                const begin = this.literalNode(yyyymmdd.toFormat(fTimestamp));
+                const next = yyyymmdd.plus({ day: 1 });
+                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
+            }
+            case 'hour': {
+                const ymdh = luxon_1.DateTime.fromFormat(literal, fHour);
+                const begin = this.literalNode(ymdh.toFormat(fTimestamp));
+                const next = ymdh.plus({ hour: 1 });
+                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
+            }
+            case 'minute': {
+                const ymdhm = luxon_1.DateTime.fromFormat(literal, fMinute);
+                const begin = this.literalNode(ymdhm.toFormat(fTimestamp));
+                const next = ymdhm.plus({ minute: 1 });
+                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
+            }
+            case 'week': {
+                const a = luxon_1.DateTime.fromFormat(literal.slice(0, 10), fDay);
+                // Luxon uses monday weeks, so look for the Monday week which contains
+                // the day after, which for all days except Sunday is the same as
+                // the sunday week, and on Sunday it is this monday week instead of
+                // last monday week.
+                const mondayWeek = a.plus({ day: 1 }).startOf('week');
+                // Now back that up by one day and we have the Sunday week
+                const ymd_wk = mondayWeek.minus({ day: 1 });
+                const begin = this.literalNode(ymd_wk.toFormat(fTimestamp));
+                const next = ymd_wk.plus({ days: 7 });
+                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
+            }
+            case 'quarter': {
+                const yyyy = literal.slice(0, 4);
+                const q = literal.slice(6);
+                if (q === '1') {
+                    literal = `${yyyy}-01-01 00:00:00`;
+                }
+                else if (q === '2') {
+                    literal = `${yyyy}-03-01 00:00:00`;
+                }
+                else if (q === '3') {
+                    literal = `${yyyy}-06-01 00:00:00`;
+                }
+                else {
+                    literal = `${yyyy}-09-01 00:00:00`;
+                }
+                const begin = this.literalNode(literal);
+                const ymd_q = luxon_1.DateTime.fromFormat(literal, fTimestamp);
+                const next = ymd_q.plus({ months: 3 });
+                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
+            }
+            case undefined:
+            case 'second':
+                return { begin: this.literalNode(literal), end: literal };
+        }
+    }
+    literalNode(literal) {
+        const literalNode = {
+            node: 'timeLiteral',
+            typeDef: { type: 'timestamp' },
+            literal,
+        };
+        return { ...literalNode, sql: this.d.sqlLiteralTime({}, literalNode) };
+    }
+    nowExpr() {
+        return {
+            node: 'now',
+            typeDef: { type: 'timestamp' },
+            sql: this.d.sqlNowExpr(),
+        };
+    }
+    n(literal) {
+        return { node: 'numberLiteral', literal, sql: literal };
+    }
+    delta(from, op, n, units) {
+        const ret = {
+            node: 'delta',
+            op,
+            units,
+            kids: {
+                base: (0, malloy_types_1.mkTemporal)(from, 'timestamp'),
+                delta: this.n(n),
+            },
+        };
+        return { ...ret, sql: this.d.sqlAlterTimeExpr(ret) };
+    }
+    dayofWeek(e) {
+        const t = {
+            node: 'extract',
+            e: (0, malloy_types_1.mkTemporal)(e, 'timestamp'),
+            units: 'day_of_week',
+        };
+        return { ...t, sql: this.d.sqlTimeExtractExpr({}, t) };
+    }
+    nowDot(units) {
+        const nowTruncExpr = {
+            node: 'trunc',
+            e: this.nowExpr(),
+            units,
+        };
+        return { ...nowTruncExpr, sql: this.d.sqlTruncExpr({}, nowTruncExpr) };
+    }
+    thisUnit(units) {
+        const thisUnit = this.nowDot(units);
+        const nextUnit = this.delta(thisUnit, '+', '1', units);
+        return { begin: thisUnit, end: nextUnit.sql };
+    }
+    lastUnit(units) {
+        const thisUnit = this.nowDot(units);
+        const lastUnit = this.delta(thisUnit, '-', '1', units);
+        return { begin: lastUnit, end: thisUnit.sql };
+    }
+    nextUnit(units) {
+        const thisUnit = this.nowDot(units);
+        const nextUnit = this.delta(thisUnit, '+', '1', units);
+        const next2Unit = this.delta(thisUnit, '+', '2', units);
+        return { begin: nextUnit, end: next2Unit.sql };
+    }
+    mod7(n) {
+        return this.d.hasModOperator ? `(${n})%7` : `MOD(${n},7)`;
+    }
+    moment(m) {
+        switch (m.moment) {
+            // mtoy todo moments which have no duration should have somethign in the interface?
+            case 'now': {
+                const now = this.nowExpr();
+                return { begin: now, end: now.sql };
+            }
+            case 'literal':
+                return this.expandLiteral(m);
+            case 'ago':
+            case 'from_now': {
+                // mtoy todo just pretending all units work, they don't
+                const nowTruncExpr = {
+                    node: 'trunc',
+                    e: this.nowExpr(),
+                    units: m.units,
+                };
+                nowTruncExpr.sql = this.d.sqlTruncExpr({}, nowTruncExpr);
+                const nowTrunc = (0, malloy_types_1.mkTemporal)(nowTruncExpr, 'timestamp');
+                const beginExpr = this.delta(nowTrunc, m.moment === 'ago' ? '-' : '+', m.n, m.units);
+                // Now the end is one unit after that .. either n-1 units ago or n+1 units from now
+                if (m.moment === 'ago' && m.n === '1') {
+                    return { begin: beginExpr, end: nowTruncExpr.sql };
+                }
+                const oneDifferent = Number(m.n) + m.moment === 'ago' ? -1 : 1;
+                const endExpr = {
+                    ...beginExpr,
+                    kids: { base: nowTrunc, delta: this.n(oneDifferent.toString()) },
+                };
+                return { begin: beginExpr, end: this.d.sqlAlterTimeExpr(endExpr) };
+            }
+            case 'today':
+                return this.thisUnit('day');
+            case 'yesterday':
+                return this.lastUnit('day');
+            case 'tomorrow':
+                return this.nextUnit('day');
+            case 'this':
+                return this.thisUnit(m.units);
+            case 'last':
+                return this.lastUnit(m.units);
+            case 'next':
+                return this.nextUnit(m.units);
+            case 'monday':
+            case 'tuesday':
+            case 'wednesday':
+            case 'thursday':
+            case 'friday':
+            case 'saturday':
+            case 'sunday': {
+                const destDay = [
+                    'sunday',
+                    'monday',
+                    'tuesday',
+                    'wednesday',
+                    'thursday',
+                    'friday',
+                    'saturday',
+                ].indexOf(m.moment);
+                const dow = this.dayofWeek(this.nowExpr()).sql;
+                if (m.which === 'next') {
+                    const nForwards = `${this.mod7(`${destDay}-(${dow}-1)+6`)}+1`;
+                    const begin = this.delta(this.thisUnit('day').begin, '+', nForwards, 'day');
+                    const end = this.delta(this.thisUnit('day').begin, '+', `${nForwards}+1`, 'day');
+                    // console.log(
+                    //   `SELECT ${
+                    //     this.nowExpr().sql
+                    //   } as now,\n  ${destDay} as destDay,\n  ${dow} as dow,\n  ${nForwards} as nForwards,\n  ${
+                    //     begin.sql
+                    //   } as begin,\n   ${end.sql} as end`
+                    // );
+                    return { begin, end: end.sql };
+                }
+                // dacks back = mod((daw0 - dst) + 6, 7) + 1;
+                // dacks back = mod(((daw - 1) - dst) + 6, 7) + 1;
+                // dacks back = mod(((daw) - dst) + 7, 7) + 1;
+                const nBack = `${this.mod7(`(${dow}-1)-${destDay}+6`)}+1`;
+                const begin = this.delta(this.thisUnit('day').begin, '-', nBack, 'day');
+                const end = this.delta(this.thisUnit('day').begin, '-', `(${nBack})-1`, 'day');
+                // console.log(
+                //   `SELECT ${
+                //     this.nowExpr().sql
+                //   } as now,\n  ${destDay} as destDay,\n  ${dow} as dow,\n  ${nBack} as nBack,\n  ${
+                //     begin.sql
+                //   } as begin,\n   ${end.sql} as end`
+                // );
+                return { begin, end: end.sql };
+            }
+        }
+    }
+    isIn(notIn, begin, end) {
+        let begOp = '>=';
+        let endOp = '<';
+        let joinOp = 'AND';
+        if (notIn) {
+            joinOp = 'OR';
+            begOp = '<';
+            endOp = '>=';
+        }
+        return `${this.expr} ${begOp} ${begin} ${joinOp} ${this.expr} ${endOp} ${end}`;
+    }
+}
+exports.TemporalFilterCompiler = TemporalFilterCompiler;
+//# sourceMappingURL=filter_temporal_compiler.js.map

package/dist/model/malloy_query.js

@@ -31,6 +31,7 @@ const utils_1 = require("./utils");
 const utils_2 = require("./materialization/utils");
 const annotation_1 = require("../annotation");
 const filter_compilers_1 = require("./filter_compilers");
+const malloy_filter_1 = require("@malloydata/malloy-filter");
 function pathToCol(path) {
     return path.map(el => encodeURIComponent(el)).join('/');
 }
@@ -885,9 +886,14 @@ class QueryField extends QueryNode {
             case 'filterMatch':
                 if (expr.dataType === 'string' ||
                     expr.dataType === 'number' ||
+                    expr.dataType === 'date' ||
+                    expr.dataType === 'timestamp' ||
                     expr.dataType === 'boolean') {
-                    return filter_compilers_1.FilterCompilers.compile(expr.dataType, expr.filter, expr.e.sql || '', this.parent.dialect);
+                    if ((0, malloy_filter_1.isFilterExpression)(expr.filter)) {
+                        return filter_compilers_1.FilterCompilers.compile(expr.dataType, expr.filter, expr.e.sql || '', this.parent.dialect);
+                    }
                 }
+                // mtoy todo no throw
                 throw new Error(`Internal Error: Filter Compiler Undefined (FCU) ${expr.dataType}`);
             default:
                 throw new Error(`Internal Error: Unknown expression node '${expr.node}' ${JSON.stringify(expr, undefined, 2)}`);

package/dist/model/malloy_types.d.ts

@@ -114,11 +114,14 @@ export interface ParameterNode extends ExprLeaf {
 }
 export interface NowNode extends ExprLeaf {
     node: 'now';
+    typeDef: {
+        type: 'timestamp';
+    };
 }
 interface HasTimeValue {
     typeDef: TemporalTypeDef;
 }
-type TimeExpr = Expr & HasTimeValue;
+export type TimeExpr = Expr & HasTimeValue;
 export declare function mkTemporal(e: Expr, timeType: TemporalTypeDef | TemporalFieldType): TimeExpr;
 export interface MeasureTimeExpr extends ExprWithKids {
     node: 'timeDiff';

package/dist/model/malloy_types.js

@@ -58,9 +58,11 @@ function canMakeTemporal(e) {
     return e.node !== 'arrayLiteral' && e.node !== 'recordLiteral';
 }
 function mkTemporal(e, timeType) {
-    const ttd = typeof timeType === 'string' ? { type: timeType } : timeType;
-    if (canMakeTemporal(e)) {
-        return { ...e, typeDef: { ...ttd } };
+    if (!('typeDef' in e)) {
+        const ttd = typeof timeType === 'string' ? { type: timeType } : timeType;
+        if (canMakeTemporal(e)) {
+            return { ...e, typeDef: { ...ttd } };
+        }
     }
     return e;
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.245";
+export declare const MALLOY_VERSION = "0.0.246";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.245';
+exports.MALLOY_VERSION = '0.0.246';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.245",
+  "version": "0.0.246-dev250320220920",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -41,9 +41,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "^0.0.245",
-    "@malloydata/malloy-interfaces": "^0.0.245",
-    "@malloydata/malloy-tag": "^0.0.245",
+    "@malloydata/malloy-filter": "^0.0.246-dev250320220920",
+    "@malloydata/malloy-interfaces": "^0.0.246-dev250320220920",
+    "@malloydata/malloy-tag": "^0.0.246-dev250320220920",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jest-diff": "^29.6.2",