@malloydata/malloy 0.0.434 → 0.0.436

package/dist/dialect/dialect.js

@@ -4,9 +4,9 @@
  * SPDX-License-Identifier: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dialect = exports.dayIndex = exports.EscapeStyle = exports.MAX_DECIMAL38 = exports.MIN_DECIMAL38 = exports.MAX_INT128 = exports.MIN_INT128 = exports.MAX_INT64 = exports.MIN_INT64 = exports.MAX_INT32 = exports.MIN_INT32 = void 0;
+exports.Dialect = exports.dayIndex = exports.CivilTime = exports.EscapeStyle = exports.MAX_DECIMAL38 = exports.MIN_DECIMAL38 = exports.MAX_INT128 = exports.MIN_INT128 = exports.MAX_INT64 = exports.MIN_INT64 = exports.MAX_INT32 = exports.MIN_INT32 = void 0;
 exports.inDays = inDays;
-exports.qtz = qtz;
+exports.queryZone = queryZone;
 exports.turtleGroupSetCondition = turtleGroupSetCondition;
 const malloy_types_1 = require("../model/malloy_types");
 const table_path_1 = require("./table-path");
@@ -37,6 +37,14 @@ exports.EscapeStyle = {
     Backslash: 'backslash',
     Unset: 'unset',
 };
+/**
+ * The two kinds of civil time: a calendar date, and a date with a time of
+ * day. Neither has a zone.
+ */
+exports.CivilTime = {
+    Date: 'date',
+    DateAndTime: 'date_and_time',
+};
 const allUnits = [
     'microsecond',
     'millisecond',
@@ -53,14 +61,10 @@ exports.dayIndex = allUnits.indexOf('day');
 function inDays(units) {
     return allUnits.indexOf(units) >= exports.dayIndex;
 }
-// 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;
+/** The query time zone, or UTC when the query has none. */
+function queryZone(qi) {
+    var _a;
+    return (_a = qi.queryTimezone) !== null && _a !== void 0 ? _a : 'UTC';
 }
 /**
  * The per-element condition for an aggregate turtle (sqlAggregateTurtle). On
@@ -81,6 +85,12 @@ function turtleGroupSetCondition(groupSet, filterSQL) {
 }
 class Dialect {
     constructor() {
+        /**
+         * What the compiler consults, not `experimental` itself. The test harness
+         * calls `acceptExperimental()` on the dialect under test so the shared
+         * suites can run on an experimental dialect without every test enabling it.
+         */
+        this.experimentalAccepted = false;
         // -- we should add flags with default values from now on so as to not break
         // dialects outside our repository
         //
@@ -106,6 +116,9 @@ class Dialect {
         this.readsNestedData = true;
         // ORDER BY 1 DESC
         this.orderByClause = 'ordinal';
+        // GROUP BY 1, or GROUP BY the dimension expressions for an engine whose
+        // GROUP BY takes no ordinals
+        this.groupByClause = 'ordinal';
         // null will match in a function signature
         this.nullMatchesFunctionSignature = true;
         // support select * replace(...)
@@ -147,6 +160,8 @@ class Dialect {
         this.booleanType = 'supported';
         // Like characters are escaped with ESCAPE clause
         this.likeEscape = true;
+        // Characters LIKE reads as wildcards beyond % and _, escaped like them
+        this.likeExtraWildcards = [];
         /**
          * Mappings from integer value ranges to Malloy number types.
          *
@@ -209,6 +224,12 @@ class Dialect {
          */
         this.identifierEscapeStyle = exports.EscapeStyle.Unset;
     }
+    isExperimental() {
+        return this.experimental && !this.experimentalAccepted;
+    }
+    acceptExperimental() {
+        this.experimentalAccepted = true;
+    }
     // Generate the lateral join bag clause for window function partitioning.
     // The expressions are dimension fields that need to be referenced by name
     // in PARTITION BY clauses. Must be overridden by any dialect that sets
@@ -219,6 +240,14 @@ class Dialect {
         }
         throw new Error('Internal error: sqlLateralJoinBag called but cantPartitionWindowFunctionsOnExpressions is false');
     }
+    /** The ordering and row limit which end a SELECT stage */
+    sqlOrderByLimit(orderTerms, limit) {
+        let s = orderTerms.length > 0 ? this.sqlOrderBy(orderTerms, 'query') + '\n' : '';
+        if (limit !== undefined) {
+            s += `LIMIT ${limit}\n`;
+        }
+        return s;
+    }
     /**
      * Determine the Malloy number type for a numeric literal.
      */
@@ -406,96 +435,70 @@ class Dialect {
     ignoreInProject(_fieldName) {
         return false;
     }
-    /**
-     * Determines whether a truncation and/or offset operation needs to be performed in
-     * civil (local) time, and if so, which timezone to use.
-     *
-     * Calendar-based operations (day, week, month, quarter, year) typically need civil time
-     * computation because these units can cross DST boundaries, changing the UTC offset.
-     *
-     * Default implementation:
-     * - Returns true for timestamps with truncation or calendar-unit offsets
-     * - Uses the query timezone from QueryInfo, or 'UTC' if none specified
-     * - Returns false for dates or sub-day offsets (hour, minute, second)
-     *
-     * Dialects can override this if they have different rules about which operations
-     * require civil time computation.
-     *
-     * @param typeDef The Malloy type of the base expression
-     * @param truncateTo The truncation unit, if any
-     * @param offsetUnit The offset unit, if any
-     * @param qi Query information including timezone settings
-     * @returns Object with `needed` boolean and optional `tz` string
-     */
-    needsCivilTimeComputation(typeDef, truncateTo, offsetUnit, qi) {
-        // Calendar units that can cross DST boundaries
-        const calendarUnits = ['day', 'week', 'month', 'quarter', 'year'];
-        const isCalendarTruncate = truncateTo !== undefined && calendarUnits.includes(truncateTo);
-        const isCalendarOffset = offsetUnit !== undefined && calendarUnits.includes(offsetUnit);
-        const tz = qtz(qi);
-        // Timestamps with calendar truncation/offset need civil time computation
-        // BUT only if there's actually a timezone to convert to/from
-        const needed = malloy_types_1.TD.isAnyTimestamp(typeDef) &&
-            (isCalendarTruncate || isCalendarOffset) &&
-            tz !== undefined;
-        return { needed, tz };
+    sqlTimeExtractExpr(qi, from) {
+        const time = from.e;
+        if (malloy_types_1.TD.isAnyTimestamp(time.typeDef)) {
+            const civil = this.sqlConvertToCivilTime(time.sql, queryZone(qi), time.typeDef);
+            return this.sqlCivilExtract(civil, from.units, exports.CivilTime.DateAndTime);
+        }
+        return this.sqlCivilExtract(time.sql, from.units, exports.CivilTime.Date);
     }
     /**
-     * Unified function for truncation and/or offset operations. This turns out to
-     * be a very common operation and one which can be optimized by doing it together.
-     *
-     * Much of the complexity has to do with getting timezone values set up so that
-     * they will truncate/offset in the query timezone instead of UTC.
-     *
-     * The intention is that this implementation will work for all dialects, and all
-     * the dialect peculiarities are handled with the new primitives introduced to
-     * support this function:
-     * - needsCivilTimeComputation: Determines if operation needs civil time
-     * - sqlConvertToCivilTime/sqlConvertFromCivilTime: Timezone conversion
-     * - sqlTruncate: Truncation operation
-     * - sqlOffsetTime: Interval arithmetic
-     *
-     * OFFSET TIMESTAMP BEHAVIOR:
-     * - Plain timestamps (offset=false): Always return plain TIMESTAMP in UTC
-     * - Offset timestamps (offset=true):
-     *   - Simple path: Operate in native embedded timezone, return TIMESTAMPTZ
-     *   - Civil path: Convert to query timezone (preserving instant), operate there,
-     *     return TIMESTAMPTZ in query timezone via sqlConvertFromCivilTime
-     * - BigQuery/MySQL: No offset timestamp support, this logic never runs
-     *
-     * @param baseExpr The time expression to operate on (already compiled, with .sql populated)
-     * @param qi Query information including timezone
-     * @param truncateTo Optional truncation unit (year, month, day, etc.)
-     * @param offset Optional offset to apply (after truncation if both present)
+     * Truncation and/or offset, the offset applied after the truncation.
+     * Doing both in one pass converts to and from civil time only once.
      */
     sqlTruncAndOffset(baseExpr, qi, truncateTo, offset) {
-        // Determine if we need to work in civil (local) time
-        if (malloy_types_1.TD.isAnyTimestamp(baseExpr.typeDef)) {
-            const { needed: needsCivil, tz } = this.needsCivilTimeComputation(baseExpr.typeDef, truncateTo, offset === null || offset === void 0 ? void 0 : offset.unit, qi);
-            if (needsCivil && tz) {
-                // Civil time path: convert to local time, operate, convert back to UTC
-                const civilResult = this.sqlConvertToCivilTime(baseExpr.sql, tz, baseExpr.typeDef);
-                let expr = civilResult.sql;
-                const civilTypeDef = civilResult.typeDef;
-                if (truncateTo) {
-                    expr = this.sqlTruncate(expr, truncateTo, civilTypeDef, true, tz);
-                }
-                if (offset) {
-                    expr = this.sqlOffsetTime(expr, offset.op, offset.magnitude, offset.unit, civilTypeDef, true, tz);
-                }
-                return this.sqlConvertFromCivilTime(expr, tz, baseExpr.typeDef);
-            }
+        const timeType = baseExpr.typeDef;
+        if (!malloy_types_1.TD.isAnyTimestamp(timeType)) {
+            return this.civilTruncAndOffset(baseExpr.sql, exports.CivilTime.Date, truncateTo, offset);
         }
-        // Simple path: no civil time conversion needed
-        let sql = baseExpr.sql;
+        const usesQueryZone = truncateTo !== undefined ||
+            (offset !== undefined && (0, malloy_types_1.isDateUnit)(offset.unit));
+        const zone = usesQueryZone ? queryZone(qi) : 'UTC';
+        const civil = this.sqlConvertToCivilTime(baseExpr.sql, zone, timeType);
+        return this.sqlConvertFromCivilTime(this.civilTruncAndOffset(civil, exports.CivilTime.DateAndTime, truncateTo, offset), zone, timeType);
+    }
+    civilTruncAndOffset(expr, civilType, truncateTo, offset) {
+        let sql = expr;
         if (truncateTo) {
-            sql = this.sqlTruncate(sql, truncateTo, baseExpr.typeDef, false, qtz(qi));
+            sql = this.sqlTruncate(sql, truncateTo, civilType);
         }
         if (offset) {
-            sql = this.sqlOffsetTime(sql, offset.op, offset.magnitude, offset.unit, baseExpr.typeDef, false, qtz(qi));
+            sql = this.sqlOffsetTime(sql, offset.op, offset.magnitude, offset.unit, civilType);
         }
         return sql;
     }
+    /**
+     * A cast between date, timestamp and timestamptz, or undefined for any
+     * other cast.
+     */
+    sqlTimeCast(qi, cast) {
+        var _a;
+        const { srcTypeDef, dstTypeDef } = this.sqlCastPrep(cast);
+        const expr = (_a = cast.e.sql) !== null && _a !== void 0 ? _a : '';
+        if (malloy_types_1.TD.isAnyTimestamp(srcTypeDef)) {
+            if (malloy_types_1.TD.isDate(dstTypeDef)) {
+                return this.sqlCivilToDate(this.sqlConvertToCivilTime(expr, queryZone(qi), srcTypeDef));
+            }
+            if (malloy_types_1.TD.isAnyTimestamp(dstTypeDef) &&
+                dstTypeDef.type !== srcTypeDef.type) {
+                // The same instant in another SQL type. A round trip through civil
+                // time in any zone keeps the instant; UTC costs the least.
+                return this.sqlConvertFromCivilTime(this.sqlConvertToCivilTime(expr, 'UTC', srcTypeDef), 'UTC', dstTypeDef);
+            }
+        }
+        if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isAnyTimestamp(dstTypeDef)) {
+            return this.sqlConvertFromCivilTime(this.sqlDateToCivil(expr), queryZone(qi), dstTypeDef);
+        }
+        return undefined;
+    }
+    /**
+     * The timestamp at which `timezone`, or the query time zone when there is
+     * none, shows the civil time `literal`.
+     */
+    sqlTimestampLiteral(qi, literal, timezone) {
+        return this.sqlConvertFromCivilTime(this.sqlCivilLiteral(literal), timezone !== null && timezone !== void 0 ? timezone : queryZone(qi), { type: 'timestamp' });
+    }
     /**
      * Reject characters that can break SQL literals or
      * be changed by SQL formatting. Timezone-name validity belongs to the
@@ -549,6 +552,7 @@ class Dialect {
      * @returns The SQL translation of the expression, or undefined
      */
     exprToSQL(qi, df) {
+        var _a;
         switch (df.node) {
             case 'now':
                 return this.sqlNowExpr();
@@ -578,7 +582,7 @@ class Dialect {
             case 'extract':
                 return this.sqlTimeExtractExpr(qi, df);
             case 'cast':
-                return this.sqlCast(qi, df);
+                return (_a = this.sqlTimeCast(qi, df)) !== null && _a !== void 0 ? _a : this.sqlCast(qi, df);
             case 'regexpMatch':
                 return this.sqlRegexpMatch(df);
             case '/': {
@@ -623,7 +627,9 @@ class Dialect {
     _func) {
         return 'sqlAggDistinct called but not implemented';
     }
-    sqlSampleTable(tableSQL, sample) {
+    // onBaseTable: the source is a table the engine can sample in place; a
+    // dialect whose sampling reads the table itself ignores a sample elsewhere
+    sqlSampleTable(tableSQL, sample, _onBaseTable = true) {
         if (sample !== undefined) {
             throw new Error(`Sampling is not supported on dialect ${this.name}.`);
         }
@@ -694,6 +700,11 @@ class Dialect {
                 escapeActive = false;
                 escapeClause = true;
             }
+            else if (this.likeEscape && this.likeExtraWildcards.includes(c)) {
+                escaped += '^' + c;
+                escapeActive = false;
+                escapeClause = true;
+            }
             else {
                 if (escapeActive) {
                     if (this.likeEscape) {
@@ -720,10 +731,30 @@ class Dialect {
      */
     sqlBoolean(bv) {
         if (this.booleanType === 'none') {
-            return bv ? '(1=1)' : '(1-0)';
+            return bv ? '(1=1)' : '(1=0)';
         }
         return bv ? 'true' : 'false';
     }
+    /**
+     * Malloy's `not`: of NULL, true. A dialect with booleanType 'none' has no
+     * boolean value for COALESCE to return, so the test is written as a
+     * condition.
+     */
+    sqlNot(condition) {
+        if (this.booleanType === 'none') {
+            return `(CASE WHEN ${condition} THEN 1 ELSE 0 END = 0)`;
+        }
+        return `COALESCE(NOT ${condition},TRUE)`;
+    }
+    /**
+     * A condition Malloy defines as true when SQL says NULL: `!=` and `!~`
+     */
+    sqlNullIsTrue(condition) {
+        if (this.booleanType === 'none') {
+            return `(CASE WHEN NOT (${condition}) THEN 1 ELSE 0 END = 0)`;
+        }
+        return `COALESCE(${condition},true)`;
+    }
     /**
      * What a boolean value looks like in a query result
      */

package/dist/dialect/dialect_map.js

@@ -14,6 +14,7 @@ const standardsql_1 = require("./standardsql");
 const trino_1 = require("./trino");
 const mysql_1 = require("./mysql");
 const databricks_1 = require("./databricks");
+const sqlserver_1 = require("./sqlserver");
 const dialectMap = new Map();
 function getDialect(name) {
     const d = dialectMap.get(name);
@@ -36,4 +37,5 @@ registerDialect(new trino_1.TrinoDialect());
 registerDialect(new trino_1.PrestoDialect());
 registerDialect(new mysql_1.MySQLDialect());
 registerDialect(new databricks_1.DatabricksDialect());
+registerDialect(new sqlserver_1.SQLServerDialect());
 //# sourceMappingURL=dialect_map.js.map

package/dist/dialect/duckdb/duckdb.d.ts

@@ -1,6 +1,6 @@
 import type { Sampling, AtomicTypeDef, RegexMatchExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, OrderBy, TimestampUnit } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
-import type { CompiledOrderBy, DialectFieldList, FieldReferenceType, IntegerTypeMapping } from '../dialect';
+import type { CivilTime, CompiledOrderBy, DialectFieldList, FieldReferenceType, IntegerTypeMapping } from '../dialect';
 import { PostgresBase } from '../pg_impl';
 import type { ValidateTablePathResult } from '../table-path';
 export declare class DuckDBDialect extends PostgresBase {
@@ -62,7 +62,7 @@ export declare class DuckDBDialect extends PostgresBase {
     castToString(expression: string): string;
     concat(...values: string[]): string;
     validateTypeName(sqlType: string): boolean;
-    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
+    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, _civilType: CivilTime): string;
     sqlRegexpMatch(df: RegexMatchExpr): string;
     sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
     sqlLiteralRecord(lit: RecordLiteralNode): string;

package/dist/dialect/duckdb/duckdb.js

@@ -332,7 +332,7 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
         // Brackets:             INT[ ]
         return sqlType.match(/^[A-Za-z\s(),[\]0-9]*$/) !== null;
     }
-    sqlOffsetTime(expr, op, magnitude, unit, _typeDef, _inCivilTime, _timezone) {
+    sqlOffsetTime(expr, op, magnitude, unit, _civilType) {
         // DuckDB doesn't support INTERVAL '1' WEEK, convert to days
         let offsetUnit = unit;
         let offsetMag = magnitude;

package/dist/dialect/index.d.ts

@@ -1,7 +1,7 @@
 export type { DialectFunctionOverloadDef, DefinitionBlueprint, DefinitionBlueprintMap, OverloadedDefinitionBlueprint, } from './functions/util';
 export { arg, anyExprType, makeParam, overload, minScalar, minAggregate, maxScalar, spread, param, variadicParam, literal, sql, } from './functions/util';
-export { Dialect, qtz } from './dialect';
-export type { DialectFieldList, CompiledOrderBy, LateralJoinExpression, QueryInfo, FieldReferenceType, } from './dialect';
+export { Dialect, queryZone } from './dialect';
+export type { DialectFieldList, CompiledOrderBy, LateralJoinExpression, QueryInfo, FieldReferenceType, GroupByClauseType, OrderByClauseType, } from './dialect';
 export { StandardSQLDialect } from './standardsql';
 export { PostgresDialect } from './postgres';
 export { DuckDBDialect } from './duckdb';
@@ -9,6 +9,7 @@ export { SnowflakeDialect } from './snowflake';
 export { TrinoDialect } from './trino';
 export { MySQLDialect } from './mysql';
 export { DatabricksDialect } from './databricks';
+export { SQLServerDialect } from './sqlserver';
 export { getDialect, registerDialect } from './dialect_map';
 export { getMalloyStandardFunctions } from './functions';
 export type { MalloyStandardFunctionImplementations } from './functions';

package/dist/dialect/index.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateDottedTablePath = exports.decodeDottedTablePath = exports.TinyParser = exports.getMalloyStandardFunctions = exports.registerDialect = exports.getDialect = exports.DatabricksDialect = exports.MySQLDialect = exports.TrinoDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.qtz = exports.Dialect = exports.sql = exports.literal = exports.variadicParam = exports.param = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
+exports.validateDottedTablePath = exports.decodeDottedTablePath = exports.TinyParser = exports.getMalloyStandardFunctions = exports.registerDialect = exports.getDialect = exports.SQLServerDialect = exports.DatabricksDialect = exports.MySQLDialect = exports.TrinoDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.queryZone = exports.Dialect = exports.sql = exports.literal = exports.variadicParam = exports.param = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
 var util_1 = require("./functions/util");
 Object.defineProperty(exports, "arg", { enumerable: true, get: function () { return util_1.arg; } });
 Object.defineProperty(exports, "anyExprType", { enumerable: true, get: function () { return util_1.anyExprType; } });
@@ -20,7 +20,7 @@ Object.defineProperty(exports, "literal", { enumerable: true, get: function () {
 Object.defineProperty(exports, "sql", { enumerable: true, get: function () { return util_1.sql; } });
 var dialect_1 = require("./dialect");
 Object.defineProperty(exports, "Dialect", { enumerable: true, get: function () { return dialect_1.Dialect; } });
-Object.defineProperty(exports, "qtz", { enumerable: true, get: function () { return dialect_1.qtz; } });
+Object.defineProperty(exports, "queryZone", { enumerable: true, get: function () { return dialect_1.queryZone; } });
 var standardsql_1 = require("./standardsql");
 Object.defineProperty(exports, "StandardSQLDialect", { enumerable: true, get: function () { return standardsql_1.StandardSQLDialect; } });
 var postgres_1 = require("./postgres");
@@ -35,6 +35,8 @@ var mysql_1 = require("./mysql");
 Object.defineProperty(exports, "MySQLDialect", { enumerable: true, get: function () { return mysql_1.MySQLDialect; } });
 var databricks_1 = require("./databricks");
 Object.defineProperty(exports, "DatabricksDialect", { enumerable: true, get: function () { return databricks_1.DatabricksDialect; } });
+var sqlserver_1 = require("./sqlserver");
+Object.defineProperty(exports, "SQLServerDialect", { enumerable: true, get: function () { return sqlserver_1.SQLServerDialect; } });
 var dialect_map_1 = require("./dialect_map");
 Object.defineProperty(exports, "getDialect", { enumerable: true, get: function () { return dialect_map_1.getDialect; } });
 Object.defineProperty(exports, "registerDialect", { enumerable: true, get: function () { return dialect_map_1.registerDialect; } });

package/dist/dialect/mysql/mysql.d.ts

@@ -1,5 +1,5 @@
-import type { Sampling, MeasureTimeExpr, RegexMatchExpr, TimeExtractExpr, TypecastExpr, BasicAtomicTypeDef, AtomicTypeDef, TimestampTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
-import type { BooleanTypeSupport, CompiledOrderBy, DialectFieldList, FieldReferenceType, OrderByClauseType, QueryInfo } from '../dialect';
+import type { Sampling, MeasureTimeExpr, RegexMatchExpr, TypecastExpr, BasicAtomicTypeDef, AtomicTypeDef, ArrayLiteralNode, RecordLiteralNode, ATimestampTypeDef, TimestampUnit, ExtractUnit } from '../../model/malloy_types';
+import type { CivilTime, BooleanTypeSupport, CompiledOrderBy, DialectFieldList, FieldReferenceType, OrderByClauseType, QueryInfo } from '../dialect';
 import { Dialect } from '../dialect';
 import type { DialectFunctionOverloadDef } from '../functions';
 export declare class MySQLDialect extends Dialect {
@@ -60,18 +60,17 @@ export declare class MySQLDialect extends Dialect {
     sqlSelectAliasAsStruct(_alias: string, _fieldList: DialectFieldList): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
     sqlNowExpr(): string;
-    sqlConvertToCivilTime(expr: string, timezone: string, _typeDef: AtomicTypeDef): {
-        sql: string;
-        typeDef: AtomicTypeDef;
-    };
-    sqlConvertFromCivilTime(expr: string, timezone: string, _destTypeDef: TimestampTypeDef): string;
-    sqlTruncate(expr: string, unit: string, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
-    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: string, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
-    sqlTimeExtractExpr(qi: QueryInfo, te: TimeExtractExpr): string;
-    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlConvertToCivilTime(expr: string, timezone: string, _typeDef: ATimestampTypeDef): string;
+    sqlConvertFromCivilTime(expr: string, timezone: string, _destTypeDef: ATimestampTypeDef): string;
+    sqlTruncate(expr: string, unit: TimestampUnit, _civilType: CivilTime): string;
+    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, _civilType: CivilTime): string;
+    sqlCivilExtract(expr: string, units: ExtractUnit, _civilType: CivilTime): string;
+    sqlCivilToDate(expr: string): string;
+    sqlDateToCivil(expr: string): string;
+    sqlCast(_qi: QueryInfo, cast: TypecastExpr): string;
     sqlRegexpMatch(df: RegexMatchExpr): string;
     sqlDateLiteral(_qi: QueryInfo, literal: string): string;
-    sqlTimestampLiteral(qi: QueryInfo, literal: string, timezone: string | undefined): string;
+    sqlCivilLiteral(literal: string): string;
     sqlTimestamptzLiteral(_qi: QueryInfo, _literal: string, _timezone: string): string;
     sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
     sqlAggDistinct(_key: string, _values: string[], _func: (valNames: string[]) => string): string;

package/dist/dialect/mysql/mysql.js

@@ -351,17 +351,18 @@ class MySQLDialect extends dialect_1.Dialect {
     sqlNowExpr() {
         return 'LOCALTIMESTAMP';
     }
+    // Civil time is a DATETIME, which has no zone
     sqlConvertToCivilTime(expr, timezone, _typeDef) {
-        // MySQL has no timestamptz type, so typeDef.timestamptz will never be true
-        return {
-            sql: `CONVERT_TZ(${expr}, 'UTC', ${this.sqlTimezoneLiteral(timezone)})`,
-            typeDef: { type: 'timestamp' },
-        };
+        return timezone === 'UTC'
+            ? expr
+            : `CONVERT_TZ(${expr}, 'UTC', ${this.sqlTimezoneLiteral(timezone)})`;
     }
     sqlConvertFromCivilTime(expr, timezone, _destTypeDef) {
-        return `CONVERT_TZ(${expr}, ${this.sqlTimezoneLiteral(timezone)}, 'UTC')`;
+        return timezone === 'UTC'
+            ? expr
+            : `CONVERT_TZ(${expr}, ${this.sqlTimezoneLiteral(timezone)}, 'UTC')`;
     }
-    sqlTruncate(expr, unit, _typeDef, _inCivilTime, _timezone) {
+    sqlTruncate(expr, unit, _civilType) {
         // For week truncation, adjust to Sunday first
         // DAYOFWEEK returns 1=Sunday, 2=Monday, etc., so subtract (DAYOFWEEK-1) days
         const adjustedExpr = unit === 'week'
@@ -392,7 +393,7 @@ class MySQLDialect extends dialect_1.Dialect {
         }
         return `TIMESTAMP(DATE_FORMAT(${adjustedExpr}, ${format}))`;
     }
-    sqlOffsetTime(expr, op, magnitude, unit, _typeDef, _inCivilTime, _timezone) {
+    sqlOffsetTime(expr, op, magnitude, unit, _civilType) {
         // Convert quarter/week to supported units
         let offsetUnit = unit;
         let offsetMag = magnitude;
@@ -407,27 +408,18 @@ class MySQLDialect extends dialect_1.Dialect {
         const interval = `INTERVAL ${offsetMag} ${offsetUnit}`;
         return `(${expr} ${op} ${interval})`;
     }
-    sqlTimeExtractExpr(qi, te) {
-        const msUnits = msExtractionMap[te.units] || te.units;
-        let extractFrom = te.e.sql;
-        if (malloy_types_1.TD.isTimestamp(te.e.typeDef)) {
-            const tz = (0, dialect_1.qtz)(qi);
-            if (tz) {
-                extractFrom = `CONVERT_TZ(${extractFrom}, 'UTC', ${this.sqlTimezoneLiteral(tz)})`;
-            }
-        }
-        return `${msUnits}(${extractFrom})`;
+    sqlCivilExtract(expr, units, _civilType) {
+        return `${msExtractionMap[units] || units}(${expr})`;
+    }
+    sqlCivilToDate(expr) {
+        return `CAST(${expr} AS DATE)`;
+    }
+    sqlDateToCivil(expr) {
+        return `CAST(${expr} AS DATETIME)`;
     }
-    sqlCast(qi, cast) {
+    sqlCast(_qi, cast) {
         const srcSQL = cast.e.sql || 'internal-error-in-sql-generation';
-        const { op, srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
-        const tz = (0, dialect_1.qtz)(qi);
-        if (op === 'timestamp::date' && tz) {
-            return `CAST(CONVERT_TZ(${srcSQL}, 'UTC', ${this.sqlTimezoneLiteral(tz)}) AS DATE) `;
-        }
-        else if (op === 'date::timestamp' && tz) {
-            return ` CONVERT_TZ(${srcSQL}, ${this.sqlTimezoneLiteral(tz)}, 'UTC')`;
-        }
+        const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             if (cast.safe) {
                 throw new Error("Mysql dialect doesn't support Safe Cast");
@@ -445,11 +437,7 @@ class MySQLDialect extends dialect_1.Dialect {
     sqlDateLiteral(_qi, literal) {
         return `DATE '${literal}'`;
     }
-    sqlTimestampLiteral(qi, literal, timezone) {
-        const tz = timezone || (0, dialect_1.qtz)(qi);
-        if (tz) {
-            return `CONVERT_TZ('${literal}', ${this.sqlTimezoneLiteral(tz)}, 'UTC')`;
-        }
+    sqlCivilLiteral(literal) {
         return `TIMESTAMP '${literal}'`;
     }
     sqlTimestamptzLiteral(_qi, _literal, _timezone) {

package/dist/dialect/pg_impl.d.ts

@@ -1,5 +1,5 @@
-import type { ArrayLiteralNode, AtomicTypeDef, ATimestampTypeDef, RecordLiteralNode, RegexMatchExpr, TimeExtractExpr, TimestampUnit, TypecastExpr } from '../model/malloy_types';
-import type { QueryInfo } from './dialect';
+import type { ArrayLiteralNode, ATimestampTypeDef, RecordLiteralNode, ExtractUnit, RegexMatchExpr, TimestampUnit, TypecastExpr } from '../model/malloy_types';
+import type { CivilTime, QueryInfo } from './dialect';
 import { Dialect } from './dialect';
 export declare const timeExtractMap: Record<string, string>;
 /**
@@ -14,18 +14,17 @@ export declare abstract class PostgresBase extends Dialect {
     identifierQuoteChar: string;
     sqlLiteralString(literal: string): string;
     sqlNowExpr(): string;
-    sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
-    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlCivilExtract(expr: string, units: ExtractUnit, _civilType: CivilTime): string;
+    sqlCast(_qi: QueryInfo, cast: TypecastExpr): string;
     sqlRegexpMatch(df: RegexMatchExpr): string;
     sqlDateLiteral(_qi: QueryInfo, literal: string): string;
-    sqlTimestampLiteral(qi: QueryInfo, literal: string, timezone: string | undefined): string;
+    sqlCivilLiteral(literal: string): string;
     sqlTimestamptzLiteral(_qi: QueryInfo, literal: string, timezone: string): string;
     sqlLiteralRecord(_lit: RecordLiteralNode): string;
     sqlLiteralArray(lit: ArrayLiteralNode): string;
-    sqlConvertToCivilTime(expr: string, timezone: string, typeDef: AtomicTypeDef): {
-        sql: string;
-        typeDef: AtomicTypeDef;
-    };
+    sqlConvertToCivilTime(expr: string, timezone: string, typeDef: ATimestampTypeDef): string;
     sqlConvertFromCivilTime(expr: string, timezone: string, destTypeDef: ATimestampTypeDef): string;
-    sqlTruncate(expr: string, unit: TimestampUnit, _typeDef: AtomicTypeDef, inCivilTime: boolean, _timezone?: string): string;
+    sqlTruncate(expr: string, unit: TimestampUnit, _civilType: CivilTime): string;
+    sqlCivilToDate(expr: string): string;
+    sqlDateToCivil(expr: string): string;
 }