@malloydata/malloy 0.0.434 → 0.0.436

package/dist/dialect/pg_impl.js

@@ -39,46 +39,13 @@ class PostgresBase extends dialect_1.Dialect {
     sqlNowExpr() {
         return 'LOCALTIMESTAMP';
     }
-    sqlTimeExtractExpr(qi, from) {
-        const units = exports.timeExtractMap[from.units] || from.units;
-        let extractFrom = from.e.sql;
-        if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
-            const tz = (0, dialect_1.qtz)(qi);
-            if (tz) {
-                extractFrom = `(${extractFrom}::TIMESTAMPTZ AT TIME ZONE ${this.sqlTimezoneLiteral(tz)})`;
-            }
-        }
-        const extracted = `EXTRACT(${units} FROM ${extractFrom})`;
-        return from.units === 'day_of_week' ? `(${extracted}+1)` : extracted;
+    sqlCivilExtract(expr, units, _civilType) {
+        const extracted = `EXTRACT(${exports.timeExtractMap[units] || units} FROM ${expr})`;
+        return units === 'day_of_week' ? `(${extracted}+1)` : extracted;
     }
-    sqlCast(qi, cast) {
+    sqlCast(_qi, cast) {
         const expr = cast.e.sql || '';
         const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
-        const tz = (0, dialect_1.qtz)(qi);
-        // Timezone-aware casts when query timezone is set
-        if (tz && srcTypeDef && dstTypeDef) {
-            // TIMESTAMP → DATE: convert via TIMESTAMPTZ to query timezone
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `CAST((${expr}::TIMESTAMPTZ) AT TIME ZONE ${this.sqlTimezoneLiteral(tz)} AS DATE)`;
-            }
-            // TIMESTAMPTZ → DATE: convert to query timezone
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `CAST((${expr}) AT TIME ZONE ${this.sqlTimezoneLiteral(tz)} AS DATE)`;
-            }
-            // DATE → TIMESTAMP: interpret date in query timezone, return UTC timestamp
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `CAST((${expr})::TIMESTAMP AT TIME ZONE ${this.sqlTimezoneLiteral(tz)} AS TIMESTAMP)`;
-            }
-            // DATE → TIMESTAMPTZ: interpret date in query timezone
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return `(${expr})::TIMESTAMP AT TIME ZONE ${this.sqlTimezoneLiteral(tz)}`;
-            }
-            // TIMESTAMPTZ → TIMESTAMP: convert to query timezone (returns TIMESTAMP)
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `(${expr}) AT TIME ZONE ${this.sqlTimezoneLiteral(tz)}`;
-            }
-        }
-        // No special handling needed, or no query timezone
         if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
             return `${castFunc}(${expr} AS ${dstSQLType})`;
@@ -91,11 +58,7 @@ class PostgresBase 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 `TIMESTAMPTZ '${literal} ${this.checkedTimezoneName(tz)}'::TIMESTAMP`;
-        }
+    sqlCivilLiteral(literal) {
         return `TIMESTAMP '${literal}'`;
     }
     sqlTimestamptzLiteral(_qi, literal, timezone) {
@@ -109,44 +72,35 @@ class PostgresBase extends dialect_1.Dialect {
         return 'ARRAY[' + array.join(',') + ']';
     }
     sqlConvertToCivilTime(expr, timezone, typeDef) {
-        // PostgreSQL/DuckDB: AT TIME ZONE is polymorphic
-        // For timestamptz (TIMESTAMPTZ): AT TIME ZONE converts to plain TIMESTAMP (civil in timezone)
-        if (typeDef.type === 'timestamptz') {
-            return {
-                sql: `(${expr}) AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)}`,
-                typeDef: { type: 'timestamp' },
-            };
+        const tz = this.sqlTimezoneLiteral(timezone);
+        if (malloy_types_1.TD.isTimestamptz(typeDef)) {
+            return `(${expr}) AT TIME ZONE ${tz}`;
         }
-        // For plain timestamps: cast to TIMESTAMPTZ (interprets as UTC)
-        // Then AT TIME ZONE converts to plain TIMESTAMP (civil in timezone)
-        return {
-            sql: `(${expr})::TIMESTAMPTZ AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)}`,
-            typeDef: { type: 'timestamp' },
-        };
+        return timezone === 'UTC'
+            ? expr
+            : `(${expr})::TIMESTAMPTZ AT TIME ZONE ${tz}`;
     }
     sqlConvertFromCivilTime(expr, timezone, destTypeDef) {
-        if (destTypeDef.type === 'timestamptz') {
-            return `(${expr}) AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)}`;
+        const tz = this.sqlTimezoneLiteral(timezone);
+        if (malloy_types_1.TD.isTimestamptz(destTypeDef)) {
+            return `(${expr}) AT TIME ZONE ${tz}`;
         }
-        return `((${expr}) AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)})::TIMESTAMP`;
+        return timezone === 'UTC'
+            ? expr
+            : `((${expr}) AT TIME ZONE ${tz})::TIMESTAMP`;
     }
-    sqlTruncate(expr, unit, _typeDef, inCivilTime, _timezone) {
-        // PostgreSQL/DuckDB starts weeks on Monday, Malloy wants Sunday
-        // Add 1 day before truncating, subtract 1 day after
-        let truncated;
+    sqlTruncate(expr, unit, _civilType) {
+        // Weeks start on Monday here, so truncate the following day
         if (unit === 'week') {
-            truncated = `(DATE_TRUNC('${unit}', (${expr} + INTERVAL '1' DAY)) - INTERVAL '1' DAY)`;
-        }
-        else {
-            truncated = `DATE_TRUNC('${unit}', ${expr})`;
+            return `(DATE_TRUNC('${unit}', (${expr} + INTERVAL '1' DAY)) - INTERVAL '1' DAY)`;
         }
-        // DATE_TRUNC returns DATE for calendar units (day/week/month/quarter/year)
-        // When in civil time (plain TIMESTAMP), cast DATE back to TIMESTAMP to continue operations
-        const calendarUnits = ['day', 'week', 'month', 'quarter', 'year'];
-        if (inCivilTime && calendarUnits.includes(unit)) {
-            return `(${truncated})::TIMESTAMP`;
-        }
-        return truncated;
+        return `DATE_TRUNC('${unit}', ${expr})`;
+    }
+    sqlCivilToDate(expr) {
+        return `CAST(${expr} AS DATE)`;
+    }
+    sqlDateToCivil(expr) {
+        return `CAST(${expr} AS TIMESTAMP)`;
     }
 }
 exports.PostgresBase = PostgresBase;

package/dist/dialect/postgres/postgres.d.ts

@@ -1,6 +1,6 @@
-import type { Sampling, AtomicTypeDef, TypecastExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode, TimeExtractExpr, TimestampUnit } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, TypecastExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode, TimestampUnit, ExtractUnit } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
-import { type CompiledOrderBy, type DialectFieldList, type FieldReferenceType, type QueryInfo } from '../dialect';
+import { type CompiledOrderBy, type DialectFieldList, type FieldReferenceType, type QueryInfo, type CivilTime } from '../dialect';
 import { PostgresBase } from '../pg_impl';
 export declare class PostgresDialect extends PostgresBase {
     name: string;
@@ -46,7 +46,7 @@ export declare class PostgresDialect extends PostgresBase {
     sqlFinalStage(lastStageName: string, _fields: string[]): string;
     sqlSelectAliasAsStruct(alias: string): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
-    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;
     sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
     sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
     sqlSumDistinct(key: string, value: string, funcName: string): string;
@@ -66,5 +66,5 @@ export declare class PostgresDialect extends PostgresBase {
     validateTypeName(sqlType: string): boolean;
     sqlLiteralRecord(lit: RecordLiteralNode): string;
     sqlLiteralArray(lit: ArrayLiteralNode): string;
-    sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
+    sqlCivilExtract(expr: string, units: ExtractUnit, _civilType: CivilTime): string;
 }

package/dist/dialect/postgres/postgres.js

@@ -200,7 +200,7 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
     sqlCreateTableAsSelect(_tableName, _sql) {
         throw new Error('Not implemented Yet');
     }
-    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;
@@ -387,19 +387,11 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
         const array = lit.kids.values.map(val => val.sql);
         return 'JSONB_BUILD_ARRAY(' + array.join(',') + ')';
     }
-    sqlTimeExtractExpr(qi, from) {
-        const units = pg_impl_1.timeExtractMap[from.units] || from.units;
-        let extractFrom = from.e.sql;
-        if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
-            const tz = (0, dialect_1.qtz)(qi);
-            if (tz) {
-                extractFrom = `(${extractFrom}::TIMESTAMPTZ AT TIME ZONE ${this.sqlTimezoneLiteral(tz)})`;
-            }
-        }
+    sqlCivilExtract(expr, units, _civilType) {
         // PostgreSQL before 14 returns a double precision for EXTRACT, cast to integer
         // since it is common to pass an extraction to mod ( like in fitler expressions )
-        const extracted = `EXTRACT(${units} FROM ${extractFrom})::integer`;
-        return from.units === 'day_of_week' ? `(${extracted}+1)` : `(${extracted})`;
+        const extracted = `EXTRACT(${pg_impl_1.timeExtractMap[units] || units} FROM ${expr})::integer`;
+        return units === 'day_of_week' ? `(${extracted}+1)` : `(${extracted})`;
     }
 }
 exports.PostgresDialect = PostgresDialect;

package/dist/dialect/snowflake/snowflake.d.ts

@@ -1,7 +1,7 @@
-import type { Sampling, AtomicTypeDef, TimeExtractExpr, TypecastExpr, MeasureTimeExpr, RegexMatchExpr, BasicAtomicTypeDef, TimestampTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, TypecastExpr, MeasureTimeExpr, RegexMatchExpr, BasicAtomicTypeDef, ArrayLiteralNode, RecordLiteralNode, ATimestampTypeDef, TimestampUnit, ExtractUnit } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { CompiledOrderBy, DialectFieldList, FieldReferenceType, IntegerTypeMapping, QueryInfo } from '../dialect';
-import { Dialect } from '../dialect';
+import { CivilTime, Dialect } from '../dialect';
 export declare class SnowflakeDialect extends Dialect {
     name: string;
     experimental: boolean;
@@ -50,19 +50,17 @@ export declare class SnowflakeDialect extends Dialect {
     sqlCreateFunctionCombineLastStage(_lastStageName: string): string;
     sqlSelectAliasAsStruct(alias: string): string;
     sqlCreateTableAsSelect(tableName: string, sql: string): 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, from: TimeExtractExpr): string;
-    private atTz;
+    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;
     sqlNowExpr(): string;
-    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlCast(_qi: QueryInfo, cast: TypecastExpr): 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;
     sqlRegexpMatch(compare: RegexMatchExpr): string;

package/dist/dialect/snowflake/snowflake.js

@@ -249,61 +249,45 @@ ${(0, utils_1.indent)(sql)}
 );
 `;
     }
+    // Civil time is a TIMESTAMP_NTZ, which has no zone
     sqlConvertToCivilTime(expr, timezone, typeDef) {
-        // For timestamptz (TIMESTAMP_TZ): use 2-arg form
-        // Returns TIMESTAMP_TZ with timezone preserved
-        if (typeDef.type === 'timestamptz') {
-            return {
-                sql: `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(timezone)}, ${expr})`,
-                typeDef: { type: 'timestamptz' },
-            };
+        const tz = this.sqlTimezoneLiteral(timezone);
+        if (malloy_types_1.TD.isTimestamptz(typeDef)) {
+            return `CONVERT_TIMEZONE(${tz}, ${expr})::TIMESTAMP_NTZ`;
         }
-        // For plain timestamps (TIMESTAMP_NTZ): use 3-arg form
-        // Must cast to TIMESTAMP_NTZ first, returns TIMESTAMP_NTZ
-        return {
-            sql: `CONVERT_TIMEZONE('UTC', ${this.sqlTimezoneLiteral(timezone)}, (${expr})::TIMESTAMP_NTZ)`,
-            typeDef: { type: 'timestamp' },
-        };
-    }
-    sqlConvertFromCivilTime(expr, timezone, _destTypeDef) {
-        // After civil time operations, we have a TIMESTAMP_NTZ in the target timezone
-        // Convert from timezone to UTC, returning TIMESTAMP_NTZ
-        return `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(timezone)}, 'UTC', (${expr})::TIMESTAMP_NTZ)`;
-    }
-    sqlTruncate(expr, unit, _typeDef, _inCivilTime, _timezone) {
-        // Snowflake session is configured with WEEK_START=7 (Sunday)
-        // so DATE_TRUNC already truncates to Sunday - no adjustment needed
-        // Unlike PostgreSQL/DuckDB, Snowflake's DATE_TRUNC preserves the input type
-        // (TIMESTAMP_NTZ → TIMESTAMP_NTZ, TIMESTAMP_TZ → TIMESTAMP_TZ)
+        return timezone === 'UTC'
+            ? expr
+            : `CONVERT_TIMEZONE('UTC', ${tz}, (${expr})::TIMESTAMP_NTZ)`;
+    }
+    sqlConvertFromCivilTime(expr, timezone, destTypeDef) {
+        const utc = timezone === 'UTC'
+            ? expr
+            : `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(timezone)}, 'UTC', (${expr})::TIMESTAMP_NTZ)`;
+        // The session time zone is UTC
+        return malloy_types_1.TD.isTimestamptz(destTypeDef) ? `(${utc})::TIMESTAMP_TZ` : utc;
+    }
+    sqlTruncate(expr, unit, _civilType) {
+        // The session sets WEEK_START to Sunday
         return `DATE_TRUNC('${unit}', ${expr})`;
     }
-    sqlOffsetTime(expr, op, magnitude, unit, typeDef, _inCivilTime, _timezone) {
-        const funcName = typeDef.type === 'date' ? 'DATEADD' : 'TIMESTAMPADD';
+    sqlOffsetTime(expr, op, magnitude, unit, civilType) {
+        const funcName = civilType === dialect_1.CivilTime.Date ? 'DATEADD' : 'TIMESTAMPADD';
         const n = op === '+' ? magnitude : `-(${magnitude})`;
         return `${funcName}(${unit}, ${n}, ${expr})`;
     }
-    sqlTimeExtractExpr(qi, from) {
-        const extractUnits = extractionMap[from.units] || from.units;
-        let extractFrom = from.e.sql;
-        const tz = (0, dialect_1.qtz)(qi);
-        if (tz && malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
-            extractFrom = `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, ${extractFrom})`;
-        }
-        return `EXTRACT(${extractUnits} FROM ${extractFrom})`;
-    }
-    atTz(sqlExpr, tz) {
-        if (tz !== undefined) {
-            return `(
-      TO_CHAR(${sqlExpr}::TIMESTAMP_NTZ, 'YYYY-MM-DD HH24:MI:SS.FF9') ||
-      TO_CHAR(CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, '1970-01-01 00:00:00'), 'TZHTZM')
-    )::TIMESTAMP_TZ`;
-        }
-        return `${sqlExpr}::TIMESTAMP_NTZ`;
+    sqlCivilExtract(expr, units, _civilType) {
+        return `EXTRACT(${extractionMap[units] || units} FROM ${expr})`;
+    }
+    sqlCivilToDate(expr) {
+        return `TO_DATE(${expr})`;
+    }
+    sqlDateToCivil(expr) {
+        return `(${expr})::TIMESTAMP_NTZ`;
     }
     sqlNowExpr() {
         return 'CURRENT_TIMESTAMP()';
     }
-    sqlCast(qi, cast) {
+    sqlCast(_qi, cast) {
         const src = cast.e.sql || '';
         const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
         if (malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
@@ -316,50 +300,14 @@ ${(0, utils_1.indent)(sql)}
             throw new Error(`Snowflake dialect doesn't support safe cast for a few types:
         refer to: https://docs.snowflake.com/en/sql-reference/functions/try_cast`);
         }
-        const tz = (0, dialect_1.qtz)(qi);
-        // Timezone-aware casts when query timezone is set
-        if (tz && srcTypeDef && dstTypeDef) {
-            // TIMESTAMP → DATE: convert to query timezone, then to date
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `TO_DATE(CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, ${src}))`;
-            }
-            // TIMESTAMPTZ → DATE: convert to query timezone, then to date
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `TO_DATE(CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, ${src}))`;
-            }
-            // DATE → TIMESTAMP: interpret date in query timezone, return UTC timestamp
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                const retExpr = `TO_TIMESTAMP(${src})`;
-                return this.atTz(retExpr, tz);
-            }
-            // DATE → TIMESTAMPTZ: interpret date in query timezone
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                const retExpr = `TO_TIMESTAMP(${src})`;
-                return this.atTz(retExpr, tz);
-            }
-            // TIMESTAMPTZ → TIMESTAMP: convert to query timezone, get UTC wall clock
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, ${src})::TIMESTAMP_NTZ`;
-            }
-            // TIMESTAMP → TIMESTAMPTZ: interpret as UTC, convert to TIMESTAMPTZ
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return this.atTz(src, tz);
-            }
-        }
         const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
         return `${castFunc}(${src} AS ${dstSQLType})`;
     }
     sqlDateLiteral(_qi, literal) {
         return `TO_DATE('${literal}')`;
     }
-    sqlTimestampLiteral(qi, literal, timezone) {
-        const tz = timezone || (0, dialect_1.qtz)(qi);
-        let ret = `'${literal}'::TIMESTAMP_NTZ`;
-        if (tz) {
-            // Interpret the literal as being in query timezone, convert to UTC
-            ret = `CONVERT_TIMEZONE(${this.sqlTimezoneLiteral(tz)}, 'UTC', ${ret})`;
-        }
-        return ret;
+    sqlCivilLiteral(literal) {
+        return `'${literal}'::TIMESTAMP_NTZ`;
     }
     sqlTimestamptzLiteral(_qi, literal, timezone) {
         // Use TIMESTAMP_TZ_FROM_PARTS to create timestamptz

package/dist/dialect/sqlserver/dialect_functions.d.ts

@@ -0,0 +1,2 @@
+import type { DefinitionBlueprintMap } from '../functions/util';
+export declare const SQLSERVER_DIALECT_FUNCTIONS: DefinitionBlueprintMap;

package/dist/dialect/sqlserver/dialect_functions.js

@@ -0,0 +1,42 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLSERVER_DIALECT_FUNCTIONS = void 0;
+const util_1 = require("../functions/util");
+const order_by = {
+    node: 'aggregate_order_by',
+    prefix: ' WITHIN GROUP (',
+    suffix: ')',
+};
+// STRING_AGG's result is limited to 8000 bytes unless its input is a MAX type.
+const string_agg = {
+    default_separator: {
+        takes: { 'value': { dimension: 'string' } },
+        returns: { measure: 'string' },
+        supportsOrderBy: true,
+        impl: {
+            expr: (0, util_1.sql) `STRING_AGG(CAST(${(0, util_1.arg)('value')} AS NVARCHAR(MAX)), ',')${order_by}`,
+        },
+    },
+    with_separator: {
+        takes: {
+            'value': { dimension: 'string' },
+            'separator': { literal: 'string' },
+        },
+        returns: { measure: 'string' },
+        supportsOrderBy: true,
+        impl: {
+            expr: (0, util_1.sql) `STRING_AGG(CAST(${(0, util_1.arg)('value')} AS NVARCHAR(MAX)), ${(0, util_1.arg)('separator')})${order_by}`,
+        },
+    },
+};
+// No string_agg_distinct: STRING_AGG accepts no DISTINCT, so the translator
+// reports the function as unknown for this dialect.
+exports.SQLSERVER_DIALECT_FUNCTIONS = {
+    string_agg,
+    ...(0, util_1.def)('reverse', { 'str': 'string' }, 'string'),
+};
+//# sourceMappingURL=dialect_functions.js.map

package/dist/dialect/sqlserver/function_overrides.d.ts

@@ -0,0 +1,2 @@
+import type { MalloyStandardFunctionImplementations as OverrideMap } from '../functions/malloy_standard_functions';
+export declare const SQLSERVER_MALLOY_STANDARD_OVERLOADS: OverrideMap;

package/dist/dialect/sqlserver/function_overrides.js

@@ -0,0 +1,55 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLSERVER_MALLOY_STANDARD_OVERLOADS = void 0;
+// LEN ignores trailing spaces: append one character, count, subtract one
+const len = (arg) => `(LEN(${arg} + N'x') - 1)`;
+exports.SQLSERVER_MALLOY_STANDARD_OVERLOADS = {
+    ceil: { function: 'CEILING' },
+    chr: { sql: "CASE WHEN ${value} = 0 THEN '' ELSE NCHAR(${value}) END" },
+    div: { sql: 'FLOOR(${dividend} / ${divisor})' },
+    // starts_with and ends_with are written as comparisons because SQL Server
+    // has no boolean values: legal as a condition (where:, having:), a server
+    // error as a value. A NULL input matches nothing, where the standard's
+    // COALESCE(..., false) returns false.
+    ends_with: {
+        sql: `RIGHT(\${value}, ${len('${suffix}')}) = \${suffix}`,
+    },
+    ifnull: { function: 'ISNULL' },
+    // A FLOAT holds neither infinity nor NaN, so neither condition is ever true
+    is_inf: { sql: '(1=0)' },
+    is_nan: { sql: '(1=0)' },
+    length: { sql: len('${value}') },
+    ln: { sql: 'LOG(${value})' },
+    log: { sql: 'LOG(${value}, ${base})' },
+    // POWER answers in the type of its base, so an integer base truncates
+    pow: { sql: 'POWER(CAST(${base} AS FLOAT(53)), ${exponent})' },
+    round: {
+        to_integer: { sql: 'ROUND(${value}, 0)' },
+        to_precision: { sql: 'ROUND(${value}, ${precision})' },
+    },
+    atan2: { function: 'ATN2' },
+    trim: { characters: { sql: 'TRIM(${trim_characters} FROM ${value})' } },
+    starts_with: {
+        sql: `LEFT(\${value}, ${len('${prefix}')}) = \${prefix}`,
+    },
+    stddev: { function: 'STDEV' },
+    string_repeat: { function: 'REPLICATE' },
+    strpos: { sql: 'CHARINDEX(${search_string}, ${test_string})' },
+    substr: {
+        position_only: {
+            sql: `SUBSTRING(\${value}, CASE WHEN \${position} < 0 THEN ${len('${value}')} + \${position} + 1 ELSE \${position} END, ${len('${value}')})`,
+        },
+        with_length: {
+            sql: `SUBSTRING(\${value}, CASE WHEN \${position} < 0 THEN ${len('${value}')} + \${position} + 1 ELSE \${position} END, \${length})`,
+        },
+    },
+    trunc: {
+        to_integer: { sql: 'ROUND(${value}, 0, 1)' },
+        to_precision: { sql: 'ROUND(${value}, ${precision}, 1)' },
+    },
+};
+//# sourceMappingURL=function_overrides.js.map

package/dist/dialect/sqlserver/index.d.ts

@@ -0,0 +1 @@
+export * from './sqlserver';

package/dist/dialect/sqlserver/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sqlserver"), exports);
+//# sourceMappingURL=index.js.map

package/dist/dialect/sqlserver/sqlserver.d.ts

@@ -0,0 +1,101 @@
+import type { Sampling, AtomicTypeDef, ATimestampTypeDef, TypecastExpr, MeasureTimeExpr, BasicAtomicTypeDef, RegexMatchExpr, TimestampUnit, OrderBy, ExtractUnit } from '../../model/malloy_types';
+import type { DialectFunctionOverloadDef } from '../functions';
+import type { BooleanTypeSupport, DialectFieldList, FieldReferenceType, GroupByClauseType, QueryInfo } from '../dialect';
+import { CivilTime, Dialect } from '../dialect';
+import type { ValidateTablePathResult } from '../table-path';
+/** T-SQL for SQL Server 2017 and later, and Azure SQL Database. */
+export declare class SQLServerDialect extends Dialect {
+    name: string;
+    experimental: boolean;
+    stringLiteralStyle: "doubled";
+    identifierEscapeStyle: "doubled";
+    identifierQuoteChar: string;
+    defaultNumberType: string;
+    defaultDecimalType: string;
+    udfPrefix: string;
+    hasFinalStage: boolean;
+    divisionIsInteger: boolean;
+    supportsSumDistinctFunction: boolean;
+    unnestWithNumbers: boolean;
+    defaultSampling: {
+        rows: number;
+    };
+    supportUnnestArrayAgg: boolean;
+    supportsAggDistinct: boolean;
+    supportsCTEinCoorelatedSubQueries: boolean;
+    dontUnionIndex: boolean;
+    supportsQualify: boolean;
+    supportsSafeCast: boolean;
+    supportsNesting: boolean;
+    supportsPipelinesInViews: boolean;
+    supportsFullJoin: boolean;
+    readsNestedData: boolean;
+    supportsComplexFilteredSources: boolean;
+    supportsArraysInData: boolean;
+    compoundObjectInSchema: boolean;
+    supportsSelectReplace: boolean;
+    supportsTempTables: boolean;
+    booleanType: BooleanTypeSupport;
+    hasTimestamptz: boolean;
+    supportsBigIntPrecision: boolean;
+    maxIdentifierLength: number;
+    likeEscape: boolean;
+    likeExtraWildcards: string[];
+    groupByClause: GroupByClauseType;
+    tablePathBareIdentRegex: RegExp;
+    /**
+     * `[schema].[table]` is read as the ANSI-quoted path it stands for, and the
+     * canonical form is the ANSI spelling the base validates.
+     */
+    sqlValidateTableName(input: string): ValidateTablePathResult;
+    malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
+    sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
+    validateTypeName(sqlType: string): boolean;
+    sqlGroupSetTable(groupSetCount: number): string;
+    sqlAnyValue(_groupSet: number, fieldName: string): string;
+    sqlAggregateTurtle(): string;
+    sqlAnyValueTurtle(): string;
+    sqlAnyValueLastTurtle(): string;
+    sqlCoaleseMeasuresInline(): string;
+    sqlUnnestAlias(): string;
+    sqlSelectAliasAsStruct(): string;
+    sqlLiteralRecord(): string;
+    sqlLiteralArray(): string;
+    sqlFieldReference(parentAlias: string, _parentType: FieldReferenceType, childName: string, _childType: string): string;
+    private unsupported;
+    sqlUnnestPipelineHead(_isSingleton: boolean, _sourceSQLExpression: string, _fieldList?: DialectFieldList): string;
+    sqlCreateFunction(_id: string, _funcText: string): string;
+    sqlCreateFunctionCombineLastStage(_lastStageName: string, _fieldList: DialectFieldList, _orderBy: OrderBy[] | undefined): string;
+    sqlCreateTableAsSelect(tableName: string, sql: string): string;
+    sqlGenerateUUID(): string;
+    sqlLiteralString(literal: string): string;
+    sqlSumDistinctHashedKey(sqlDistinctKey: string): string;
+    sqlSumDistinct(key: string, value: string, funcName: string): string;
+    sqlAggDistinct(_key: string, _values: string[], _func: (valNames: string[]) => string): string;
+    sqlOrderByLimit(orderTerms: string[], limit: number | undefined): string;
+    sqlSampleTable(tableSQL: string, sample: Sampling | undefined, onBaseTable?: boolean): string;
+    castToString(expression: string): string;
+    concat(...values: string[]): string;
+    sqlDateToString(sqlDateExp: string): string;
+    sqlNowExpr(): 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;
+    sqlCivilLiteral(literal: string): string;
+    sqlTimestamptzLiteral(_qi: QueryInfo, literal: string, timezone: string): string;
+    sqlTimezoneLiteral(timezone: string): 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;
+    sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
+    getDialectFunctionOverrides(): {
+        [name: string]: DialectFunctionOverloadDef[];
+    };
+    getDialectFunctions(): {
+        [name: string]: DialectFunctionOverloadDef[];
+    };
+}