@malloydata/malloy 0.0.34-dev230523182411 → 0.0.34

package/dist/dialect/dialect.d.ts

@@ -4,6 +4,20 @@ interface DialectField {
     sqlExpression: string;
     sqlOutputName: string;
 }
+/**
+ * Data which dialect methods need in order to correctly generate SQL.
+ * Initially this is just timezone related, but I made this an interface
+ * so it would be extensible with other useful information which might not be
+ * available until runtime (e.g. version number of db)
+ * mtoy TODO rename this interface to something other than "QueryInfo"
+ */
+export interface QueryInfo {
+    queryTimezone?: string;
+    systemTimezone?: string;
+}
+export declare const dayIndex: number;
+export declare function inDays(units: string): boolean;
+export declare function qtz(qi: QueryInfo): string | undefined;
 /**
  * Someday this might be used to control how a function call in malloy is
  * translated into a function call in SQL. Today this is just so that
@@ -48,19 +62,20 @@ export declare abstract class Dialect {
     sqlDateToString(sqlDateExp: string): string;
     abstract sqlMaybeQuoteIdentifier(identifier: string): string;
     abstract sqlNow(): Expr;
-    abstract sqlTrunc(sqlTime: TimeValue, units: TimestampUnit): Expr;
-    abstract sqlExtract(sqlTime: TimeValue, units: ExtractUnit): Expr;
+    abstract sqlTrunc(qi: QueryInfo, sqlTime: TimeValue, units: TimestampUnit): Expr;
+    abstract sqlExtract(qi: QueryInfo, sqlTime: TimeValue, units: ExtractUnit): Expr;
     abstract sqlMeasureTime(from: TimeValue, to: TimeValue, units: TimestampUnit): Expr;
     abstract sqlAlterTime(op: '+' | '-', expr: TimeValue, n: Expr, timeframe: TimestampUnit): Expr;
     ignoreInProject(_fieldName: string): boolean;
-    abstract sqlCast(cast: TypecastFragment): Expr;
-    abstract sqlLiteralTime(timeString: string, type: TimeFieldType, timezone: string): string;
+    abstract sqlCast(qi: QueryInfo, cast: TypecastFragment): Expr;
+    abstract sqlLiteralTime(qi: QueryInfo, timeString: string, type: TimeFieldType, timezone?: string): string;
     abstract sqlLiteralString(literak: string): string;
     abstract sqlRegexpMatch(expr: Expr, regex: string): Expr;
     getFunctionInfo(functionName: string): FunctionInfo | undefined;
-    dialectExpr(df: DialectFragment): Expr;
+    dialectExpr(qi: QueryInfo, df: DialectFragment): Expr;
     sqlSumDistinct(_key: string, _value: string, _funcName: string): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
     sqlOrderBy(orderTerms: string[]): string;
+    sqlTzStr(qi: QueryInfo): string;
 }
 export {};

package/dist/dialect/dialect.js

@@ -22,8 +22,35 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dialect = void 0;
+exports.Dialect = exports.qtz = exports.inDays = exports.dayIndex = void 0;
 const malloy_types_1 = require("../model/malloy_types");
+const allUnits = [
+    'microsecond',
+    'millisecond',
+    'second',
+    'minute',
+    'hour',
+    'day',
+    'week',
+    'month',
+    'quarter',
+    'year',
+];
+exports.dayIndex = allUnits.indexOf('day');
+function inDays(units) {
+    return allUnits.indexOf(units) >= exports.dayIndex;
+}
+exports.inDays = inDays;
+// Return the active query timezone, if it different than the
+// "native" timezone for timestamps.
+function qtz(qi) {
+    const tz = qi.queryTimezone;
+    if (tz === undefined || tz === qi.systemTimezone) {
+        return undefined;
+    }
+    return tz;
+}
+exports.qtz = qtz;
 class Dialect {
     sqlFinalStage(_lastStageName, _fields) {
         throw new Error('Dialect has no final Stage but called Anyway');
@@ -40,7 +67,7 @@ class Dialect {
     getFunctionInfo(functionName) {
         return this.functionInfo[functionName.toLowerCase()];
     }
-    dialectExpr(df) {
+    dialectExpr(qi, df) {
         switch (df.function) {
             case 'now':
                 return this.sqlNow();
@@ -49,11 +76,11 @@ class Dialect {
             case 'delta':
                 return this.sqlAlterTime(df.op, df.base, df.delta, df.units);
             case 'trunc':
-                return this.sqlTrunc(df.expr, df.units);
+                return this.sqlTrunc(qi, df.expr, df.units);
             case 'extract':
-                return this.sqlExtract(df.expr, df.units);
+                return this.sqlExtract(qi, df.expr, df.units);
             case 'cast':
-                return this.sqlCast(df);
+                return this.sqlCast(qi, df);
             case 'regexpMatch':
                 return this.sqlRegexpMatch(df.expr, df.regexp);
             case 'div': {
@@ -62,8 +89,11 @@ class Dialect {
                 }
                 return (0, malloy_types_1.mkExpr) `${df.numerator}/${df.denominator}`;
             }
-            case 'timeLiteral':
-                return [this.sqlLiteralTime(df.literal, df.literalType, df.timezone)];
+            case 'timeLiteral': {
+                return [
+                    this.sqlLiteralTime(qi, df.literal, df.literalType, df.timezone),
+                ];
+            }
             case 'stringLiteral':
                 return [this.sqlLiteralString(df.literal)];
         }
@@ -80,6 +110,9 @@ class Dialect {
     sqlOrderBy(orderTerms) {
         return `ORDER BY ${orderTerms.join(',')}`;
     }
+    sqlTzStr(qi) {
+        return `"${qi.queryTimezone}"`;
+    }
 }
 exports.Dialect = Dialect;
 //# sourceMappingURL=dialect.js.map

package/dist/dialect/duckdb.d.ts

@@ -1,5 +1,5 @@
 import { DateUnit, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from '../model/malloy_types';
-import { Dialect, DialectFieldList, FunctionInfo } from './dialect';
+import { Dialect, DialectFieldList, FunctionInfo, QueryInfo } from './dialect';
 export declare class DuckDBDialect extends Dialect {
     name: string;
     defaultNumberType: string;
@@ -39,12 +39,12 @@ export declare class DuckDBDialect extends Dialect {
     getFunctionInfo(functionName: string): FunctionInfo | undefined;
     sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
     sqlNow(): Expr;
-    sqlTrunc(sqlTime: TimeValue, units: TimestampUnit): Expr;
-    sqlExtract(from: TimeValue, units: ExtractUnit): Expr;
+    sqlTrunc(qi: QueryInfo, sqlTime: TimeValue, units: TimestampUnit): Expr;
+    sqlExtract(qi: QueryInfo, from: TimeValue, units: ExtractUnit): Expr;
     sqlAlterTime(op: '+' | '-', expr: TimeValue, n: Expr, timeframe: DateUnit): Expr;
-    sqlCast(cast: TypecastFragment): Expr;
+    sqlCast(qi: QueryInfo, cast: TypecastFragment): Expr;
     sqlRegexpMatch(expr: Expr, regexp: string): Expr;
-    sqlLiteralTime(timeString: string, type: TimeFieldType, _timezone: string): string;
+    sqlLiteralTime(qi: QueryInfo, timeString: string, type: TimeFieldType, timezone: string | undefined): string;
     sqlSumDistinct(key: string, value: string, funcName: string): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
     sqlOrderBy(orderTerms: string[]): string;

package/dist/dialect/duckdb.js

@@ -28,85 +28,6 @@ const utils_1 = require("../model/utils");
 const dialect_1 = require("./dialect");
 // need to refactor runSQL to take a SQLBlock instead of just a sql string.
 const hackSplitComment = '-- hack: split on this';
-const _keywords = `
-ALL
-ANALYSE
-ANALYZE
-AND
-ANY
-ARRAY
-AS
-ASC_P
-ASYMMETRIC
-BOTH
-CASE
-CAST
-CHECK_P
-COLLATE
-COLUMN
-CONSTRAINT
-CREATE_P
-CURRENT_CATALOG
-CURRENT_DATE
-CURRENT_ROLE
-CURRENT_TIME
-CURRENT_TIMESTAMP
-CURRENT_USER
-DEFAULT
-DEFERRABLE
-DESC_P
-DISTINCT
-DO
-ELSE
-END_P
-EXCEPT
-FALSE_P
-FETCH
-FOR
-FOREIGN
-FROM
-GRANT
-GROUP_P
-HAVING
-IN_P
-INITIALLY
-INTERSECT
-INTO
-LATERAL_P
-LEADING
-LIMIT
-LOCALTIME
-LOCALTIMESTAMP
-NOT
-NULL_P
-OFFSET
-ON
-ONLY
-OR
-ORDER
-PLACING
-PRIMARY
-REFERENCES
-RETURNING
-SELECT
-SESSION_USER
-SOME
-SYMMETRIC
-TABLE
-THEN
-TO
-TRAILING
-TRUE_P
-UNION
-UNIQUE
-USER
-USING
-VARIADIC
-WHEN
-WHERE
-WINDOW
-WITH
-`.split(/\s/);
 const castMap = {
     number: 'double precision',
     string: 'varchar',
@@ -115,11 +36,6 @@ const pgExtractionMap = {
     day_of_week: 'dow',
     day_of_year: 'doy',
 };
-const inSeconds = {
-    second: 1,
-    minute: 60,
-    hour: 3600,
-};
 class DuckDBDialect extends dialect_1.Dialect {
     constructor() {
         super(...arguments);
@@ -268,42 +184,52 @@ class DuckDBDialect extends dialect_1.Dialect {
     sqlMeasureTime(from, to, units) {
         let lVal = from.value;
         let rVal = to.value;
-        if (inSeconds[units]) {
-            lVal = (0, malloy_types_1.mkExpr) `EXTRACT(EPOCH FROM ${lVal})`;
-            rVal = (0, malloy_types_1.mkExpr) `EXTRACT(EPOCH FROM ${rVal})`;
-            const duration = (0, malloy_types_1.mkExpr) `(${rVal} - ${lVal})`;
-            return units === 'second'
-                ? duration
-                : (0, malloy_types_1.mkExpr) `FLOOR(${duration}/${inSeconds[units].toString()})`;
-        }
-        if (from.valueType !== 'date') {
-            lVal = (0, malloy_types_1.mkExpr) `CAST((${lVal}) AS DATE)`;
-        }
-        if (to.valueType !== 'date') {
-            rVal = (0, malloy_types_1.mkExpr) `CAST((${rVal}) AS DATE)`;
-        }
-        if (units === 'week') {
-            // DuckDB's weeks start on Monday, but Malloy's weeks start on Sunday
-            lVal = (0, malloy_types_1.mkExpr) `(${lVal} + INTERVAL 1 DAY)`;
-            rVal = (0, malloy_types_1.mkExpr) `(${rVal} + INTERVAL 1 DAY)`;
+        if (!(0, dialect_1.inDays)(units)) {
+            if (from.valueType === 'date') {
+                lVal = (0, malloy_types_1.mkExpr) `(${lVal})::TIMESTAMP`;
+            }
+            if (to.valueType === 'date') {
+                rVal = (0, malloy_types_1.mkExpr) `(${rVal})::TIMESTAMP`;
+            }
         }
-        return (0, malloy_types_1.mkExpr) `DATE_DIFF('${units}', ${lVal}, ${rVal})`;
+        return (0, malloy_types_1.mkExpr) `DATE_SUB('${units}',${lVal},${rVal})`;
     }
     sqlNow() {
-        return (0, malloy_types_1.mkExpr) `CURRENT_TIMESTAMP::TIMESTAMP`;
+        return (0, malloy_types_1.mkExpr) `LOCALTIMESTAMP`;
     }
-    sqlTrunc(sqlTime, units) {
+    sqlTrunc(qi, sqlTime, units) {
         // adjusting for monday/sunday weeks
         const week = units === 'week';
         const truncThis = week
             ? (0, malloy_types_1.mkExpr) `${sqlTime.value} + INTERVAL 1 DAY`
             : sqlTime.value;
-        const trunced = (0, malloy_types_1.mkExpr) `DATE_TRUNC('${units}', ${truncThis})`;
-        return week ? (0, malloy_types_1.mkExpr) `(${trunced} - INTERVAL 1 DAY)` : trunced;
+        if (sqlTime.valueType === 'timestamp') {
+            const tz = (0, dialect_1.qtz)(qi);
+            if (tz) {
+                const civilSource = (0, malloy_types_1.mkExpr) `(${truncThis}::TIMESTAMPTZ AT TIME ZONE '${tz}')`;
+                let civilTrunc = (0, malloy_types_1.mkExpr) `DATE_TRUNC('${units}', ${civilSource})`;
+                // MTOY todo ... only need to do this if this is a date ...
+                civilTrunc = (0, malloy_types_1.mkExpr) `${civilTrunc}::TIMESTAMP`;
+                const truncTsTz = (0, malloy_types_1.mkExpr) `${civilTrunc} AT TIME ZONE '${tz}'`;
+                return (0, malloy_types_1.mkExpr) `(${truncTsTz})::TIMESTAMP`;
+            }
+        }
+        let result = (0, malloy_types_1.mkExpr) `DATE_TRUNC('${units}', ${truncThis})`;
+        if (week) {
+            result = (0, malloy_types_1.mkExpr) `(${result} - INTERVAL 1 DAY)`;
+        }
+        return result;
     }
-    sqlExtract(from, units) {
+    sqlExtract(qi, from, units) {
         const pgUnits = pgExtractionMap[units] || units;
-        const extracted = (0, malloy_types_1.mkExpr) `EXTRACT(${pgUnits} FROM ${from.value})`;
+        let extractFrom = from.value;
+        if (from.valueType === 'timestamp') {
+            const tz = (0, dialect_1.qtz)(qi);
+            if (tz) {
+                extractFrom = (0, malloy_types_1.mkExpr) `(${extractFrom}::TIMESTAMPTZ AT TIME ZONE '${tz}')`;
+            }
+        }
+        const extracted = (0, malloy_types_1.mkExpr) `EXTRACT(${pgUnits} FROM ${extractFrom})`;
         return units === 'day_of_week' ? (0, malloy_types_1.mkExpr) `(${extracted}+1)` : extracted;
     }
     sqlAlterTime(op, expr, n, timeframe) {
@@ -316,28 +242,36 @@ class DuckDBDialect extends dialect_1.Dialect {
             n = (0, malloy_types_1.mkExpr) `${n}*7`;
         }
         const interval = (0, malloy_types_1.mkExpr) `INTERVAL (${n}) ${timeframe}`;
-        return (0, malloy_types_1.mkExpr) `((${expr.value})) ${op} ${interval}`;
-    }
-    sqlCast(cast) {
+        return (0, malloy_types_1.mkExpr) `${expr.value} ${op} ${interval}`;
+    }
+    sqlCast(qi, cast) {
+        const op = `${cast.srcType}::${cast.dstType}`;
+        const castTo = castMap[cast.dstType] || cast.dstType;
+        const tz = (0, dialect_1.qtz)(qi);
+        if (op === 'timestamp::date' && tz) {
+            const tstz = (0, malloy_types_1.mkExpr) `${cast.expr}::TIMESTAMPTZ`;
+            return (0, malloy_types_1.mkExpr) `CAST((${tstz}) AT TIME ZONE '${tz}' AS DATE)`;
+        }
+        else if (op === 'date::timestamp' && tz) {
+            return (0, malloy_types_1.mkExpr) `CAST((${cast.expr})::TIMESTAMP AT TIME ZONE '${tz}' AS TIMESTAMP)`;
+        }
         if (cast.dstType !== cast.srcType) {
-            const castTo = castMap[cast.dstType] || cast.dstType;
-            return (0, malloy_types_1.mkExpr) `cast(${cast.expr} as ${castTo})`;
+            return (0, malloy_types_1.mkExpr) `CAST(${cast.expr} AS ${castTo})`;
         }
         return cast.expr;
     }
     sqlRegexpMatch(expr, regexp) {
         return (0, malloy_types_1.mkExpr) `REGEXP_MATCHES(${expr}, ${regexp})`;
     }
-    sqlLiteralTime(timeString, type, _timezone) {
+    sqlLiteralTime(qi, timeString, type, timezone) {
         if (type === 'date') {
             return `DATE '${timeString}'`;
         }
-        else if (type === 'timestamp') {
-            return `TIMESTAMP '${timeString}'`;
-        }
-        else {
-            throw new Error(`Unknown Literal time format ${type}`);
+        const tz = timezone || (0, dialect_1.qtz)(qi);
+        if (tz) {
+            return `TIMESTAMPTZ '${timeString} ${tz}'::TIMESTAMP`;
         }
+        return `TIMESTAMP '${timeString}'`;
     }
     sqlSumDistinct(key, value, funcName) {
         // return `sum_distinct(list({key:${key}, val: ${value}}))`;

package/dist/dialect/postgres.d.ts

@@ -1,5 +1,5 @@
 import { DateUnit, Expr, ExtractUnit, Sampling, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from '../model/malloy_types';
-import { Dialect, DialectFieldList, FunctionInfo } from './dialect';
+import { Dialect, DialectFieldList, FunctionInfo, QueryInfo } from './dialect';
 export declare class PostgresDialect extends Dialect {
     name: string;
     defaultNumberType: string;
@@ -37,12 +37,12 @@ export declare class PostgresDialect extends Dialect {
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
     sqlNow(): Expr;
-    sqlTrunc(sqlTime: TimeValue, units: TimestampUnit): Expr;
-    sqlExtract(from: TimeValue, units: ExtractUnit): Expr;
+    sqlTrunc(qi: QueryInfo, sqlTime: TimeValue, units: TimestampUnit): Expr;
+    sqlExtract(qi: QueryInfo, from: TimeValue, units: ExtractUnit): Expr;
     sqlAlterTime(op: '+' | '-', expr: TimeValue, n: Expr, timeframe: DateUnit): Expr;
-    sqlCast(cast: TypecastFragment): Expr;
+    sqlCast(qi: QueryInfo, cast: TypecastFragment): Expr;
     sqlRegexpMatch(expr: Expr, regexp: string): Expr;
-    sqlLiteralTime(timeString: string, type: TimeFieldType, _timezone: string): string;
+    sqlLiteralTime(qi: QueryInfo, timeString: string, type: TimeFieldType, timezone: string | undefined): string;
     getFunctionInfo(functionName: string): FunctionInfo | undefined;
     sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
     sqlSumDistinct(key: string, value: string, funcName: string): string;

package/dist/dialect/postgres.js

@@ -47,6 +47,8 @@ const inSeconds = {
     second: 1,
     minute: 60,
     hour: 3600,
+    day: 24 * 3600,
+    week: 7 * 24 * 3600,
 };
 class PostgresDialect extends dialect_1.Dialect {
     constructor() {
@@ -218,18 +220,39 @@ class PostgresDialect extends dialect_1.Dialect {
     sqlNow() {
         return (0, malloy_types_1.mkExpr) `CURRENT_TIMESTAMP`;
     }
-    sqlTrunc(sqlTime, units) {
+    sqlTrunc(qi, sqlTime, units) {
         // adjusting for monday/sunday weeks
         const week = units === 'week';
         const truncThis = week
-            ? (0, malloy_types_1.mkExpr) `${sqlTime.value}+interval'1'day`
+            ? (0, malloy_types_1.mkExpr) `${sqlTime.value} + INTERVAL '1' DAY`
             : sqlTime.value;
-        const trunced = (0, malloy_types_1.mkExpr) `DATE_TRUNC('${units}', ${truncThis})`;
-        return week ? (0, malloy_types_1.mkExpr) `(${trunced}-interval'1'day)` : trunced;
+        if (sqlTime.valueType === 'timestamp') {
+            const tz = (0, dialect_1.qtz)(qi);
+            if (tz) {
+                const civilSource = (0, malloy_types_1.mkExpr) `(${truncThis}::TIMESTAMPTZ AT TIME ZONE '${tz}')`;
+                let civilTrunc = (0, malloy_types_1.mkExpr) `DATE_TRUNC('${units}', ${civilSource})`;
+                // MTOY todo ... only need to do this if this is a date ...
+                civilTrunc = (0, malloy_types_1.mkExpr) `${civilTrunc}::TIMESTAMP`;
+                const truncTsTz = (0, malloy_types_1.mkExpr) `${civilTrunc} AT TIME ZONE '${tz}'`;
+                return (0, malloy_types_1.mkExpr) `(${truncTsTz})::TIMESTAMP`;
+            }
+        }
+        let result = (0, malloy_types_1.mkExpr) `DATE_TRUNC('${units}', ${truncThis})`;
+        if (week) {
+            result = (0, malloy_types_1.mkExpr) `(${result} - INTERVAL '1' DAY)`;
+        }
+        return result;
     }
-    sqlExtract(from, units) {
+    sqlExtract(qi, from, units) {
         const pgUnits = pgExtractionMap[units] || units;
-        const extracted = (0, malloy_types_1.mkExpr) `EXTRACT(${pgUnits} FROM ${from.value})`;
+        let extractFrom = from.value;
+        if (from.valueType === 'timestamp') {
+            const tz = (0, dialect_1.qtz)(qi);
+            if (tz) {
+                extractFrom = (0, malloy_types_1.mkExpr) `(${extractFrom}::TIMESTAMPTZ AT TIME ZONE '${tz}')`;
+            }
+        }
+        const extracted = (0, malloy_types_1.mkExpr) `EXTRACT(${pgUnits} FROM ${extractFrom})`;
         return units === 'day_of_week' ? (0, malloy_types_1.mkExpr) `(${extracted}+1)` : extracted;
     }
     sqlAlterTime(op, expr, n, timeframe) {
@@ -240,26 +263,34 @@ class PostgresDialect extends dialect_1.Dialect {
         const interval = (0, malloy_types_1.mkExpr) `make_interval(${pgMakeIntervalMap[timeframe]}=>${n})`;
         return (0, malloy_types_1.mkExpr) `((${expr.value})${op}${interval})`;
     }
-    sqlCast(cast) {
+    sqlCast(qi, cast) {
+        const op = `${cast.srcType}::${cast.dstType}`;
+        const castTo = castMap[cast.dstType] || cast.dstType;
+        const tz = (0, dialect_1.qtz)(qi);
+        if (op === 'timestamp::date' && tz) {
+            const tstz = (0, malloy_types_1.mkExpr) `${cast.expr}::TIMESTAMPTZ`;
+            return (0, malloy_types_1.mkExpr) `CAST((${tstz}) AT TIME ZONE '${tz}' AS DATE)`;
+        }
+        else if (op === 'date::timestamp' && tz) {
+            return (0, malloy_types_1.mkExpr) `CAST((${cast.expr})::TIMESTAMP AT TIME ZONE '${tz}' AS TIMESTAMP)`;
+        }
         if (cast.dstType !== cast.srcType) {
-            const castTo = castMap[cast.dstType] || cast.dstType;
-            return (0, malloy_types_1.mkExpr) `cast(${cast.expr} as ${castTo})`;
+            return (0, malloy_types_1.mkExpr) `CAST(${cast.expr} AS ${castTo})`;
         }
         return cast.expr;
     }
     sqlRegexpMatch(expr, regexp) {
         return (0, malloy_types_1.mkExpr) `(${expr} ~ ${regexp})`;
     }
-    sqlLiteralTime(timeString, type, _timezone) {
+    sqlLiteralTime(qi, timeString, type, timezone) {
         if (type === 'date') {
-            return `DATE('${timeString}')`;
+            return `DATE '${timeString}'`;
         }
-        else if (type === 'timestamp') {
-            return `TIMESTAMP '${timeString}'`;
-        }
-        else {
-            throw new Error(`Unknown Literal time format ${type}`);
+        const tz = timezone || (0, dialect_1.qtz)(qi);
+        if (tz) {
+            return `TIMESTAMPTZ '${timeString} ${tz}'::TIMESTAMP`;
         }
+        return `TIMESTAMP '${timeString}'`;
     }
     getFunctionInfo(functionName) {
         return this.functionInfo[functionName];
@@ -270,29 +301,10 @@ class PostgresDialect extends dialect_1.Dialect {
         if (inSeconds[units]) {
             lVal = (0, malloy_types_1.mkExpr) `EXTRACT(EPOCH FROM ${lVal})`;
             rVal = (0, malloy_types_1.mkExpr) `EXTRACT(EPOCH FROM ${rVal})`;
-            const duration = (0, malloy_types_1.mkExpr) `(${rVal} - ${lVal})`;
+            const duration = (0, malloy_types_1.mkExpr) `${rVal}-${lVal}`;
             return units === 'second'
-                ? duration
-                : (0, malloy_types_1.mkExpr) `TRUNC(${duration}/${inSeconds[units].toString()})`;
-        }
-        if (units === 'day') {
-            return (0, malloy_types_1.mkExpr) `${rVal}::date - ${lVal}::date`;
-        }
-        const yearDiff = (0, malloy_types_1.mkExpr) `(DATE_PART('year', ${rVal}) - DATE_PART('year', ${lVal}))`;
-        if (units === 'year') {
-            return yearDiff;
-        }
-        if (units === 'week') {
-            const dayDiffForWeekStart = (0, malloy_types_1.mkExpr) `(DATE_TRUNC('week', ${rVal} + '1 day'::interval)::date - DATE_TRUNC('week', ${lVal} + '1 day'::interval)::date)`;
-            return (0, malloy_types_1.mkExpr) `${dayDiffForWeekStart} / 7`;
-        }
-        if (units === 'month') {
-            const monthDiff = (0, malloy_types_1.mkExpr) `DATE_PART('month', ${rVal}) - DATE_PART('month', ${lVal})`;
-            return (0, malloy_types_1.mkExpr) `${yearDiff} * 12 + ${monthDiff}`;
-        }
-        if (units === 'quarter') {
-            const qDiff = (0, malloy_types_1.mkExpr) `DATE_PART('quarter', ${rVal}) - DATE_PART('quarter', ${lVal})`;
-            return (0, malloy_types_1.mkExpr) `${yearDiff} * 4 + ${qDiff}`;
+                ? (0, malloy_types_1.mkExpr) `FLOOR(${duration})`
+                : (0, malloy_types_1.mkExpr) `FLOOR((${duration})/${inSeconds[units].toString()}.0)`;
         }
         throw new Error(`Unknown or unhandled postgres time unit: ${units}`);
     }

package/dist/dialect/standardsql.d.ts

@@ -1,5 +1,5 @@
 import { Expr, ExtractUnit, Sampling, TimeValue, TimestampUnit, TypecastFragment } from '../model/malloy_types';
-import { Dialect, DialectFieldList, FunctionInfo } from './dialect';
+import { Dialect, DialectFieldList, FunctionInfo, QueryInfo } from './dialect';
 export declare class StandardSQLDialect extends Dialect {
     name: string;
     defaultNumberType: string;
@@ -36,13 +36,13 @@ export declare class StandardSQLDialect extends Dialect {
     keywords: string[];
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlNow(): Expr;
-    sqlTrunc(sqlTime: TimeValue, units: TimestampUnit): Expr;
-    sqlExtract(expr: TimeValue, units: ExtractUnit): Expr;
+    sqlTrunc(qi: QueryInfo, sqlTime: TimeValue, units: TimestampUnit): Expr;
+    sqlExtract(qi: QueryInfo, expr: TimeValue, units: ExtractUnit): Expr;
     sqlAlterTime(op: '+' | '-', expr: TimeValue, n: Expr, timeframe: TimestampUnit): Expr;
     ignoreInProject(fieldName: string): boolean;
-    sqlCast(cast: TypecastFragment): Expr;
+    sqlCast(qi: QueryInfo, cast: TypecastFragment): Expr;
     sqlRegexpMatch(expr: Expr, regexp: string): Expr;
-    sqlLiteralTime(timeString: string, type: 'date' | 'timestamp', timezone: string): string;
+    sqlLiteralTime(qi: QueryInfo, timeString: string, type: 'date' | 'timestamp', timezone: string | undefined): string;
     sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
     sqlLiteralString(literal: string): string;