@malloydata/malloy 0.0.177-dev240828173040 → 0.0.177-dev240829030921

package/dist/dialect/pg_impl.js

@@ -0,0 +1,91 @@
+"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.PostgresBase = exports.timeExtractMap = void 0;
+const dialect_1 = require("./dialect");
+exports.timeExtractMap = {
+    'day_of_week': 'dow',
+    'day_of_year': 'doy',
+};
+/**
+ * Many SQL implementations started with the PostGres source, and therefore can use the
+ * same implementations for the much of the SQL code generation
+ */
+class PostgresBase extends dialect_1.Dialect {
+    sqlTruncExpr(qi, df) {
+        // adjusting for monday/sunday weeks
+        const week = df.units === 'week';
+        const truncThis = week ? `${df.e.sql} + INTERVAL '1' DAY` : df.e.sql;
+        if (df.e.dataType === 'timestamp') {
+            const tz = (0, dialect_1.qtz)(qi);
+            if (tz) {
+                const civilSource = `(${truncThis}::TIMESTAMPTZ AT TIME ZONE '${tz}')`;
+                let civilTrunc = `DATE_TRUNC('${df.units}', ${civilSource})`;
+                // MTOY todo ... only need to do this if this is a date ...
+                civilTrunc = `${civilTrunc}::TIMESTAMP`;
+                const truncTsTz = `${civilTrunc} AT TIME ZONE '${tz}'`;
+                return `(${truncTsTz})::TIMESTAMP`;
+            }
+        }
+        let result = `DATE_TRUNC('${df.units}', ${truncThis})`;
+        if (week) {
+            result = `(${result} - INTERVAL '1' DAY)`;
+        }
+        return result;
+    }
+    sqlNowExpr() {
+        return 'LOCALTIMESTAMP';
+    }
+    sqlTimeExtractExpr(qi, from) {
+        const units = exports.timeExtractMap[from.units] || from.units;
+        let extractFrom = from.e.sql;
+        if (from.e.dataType === 'timestamp') {
+            const tz = (0, dialect_1.qtz)(qi);
+            if (tz) {
+                extractFrom = `(${extractFrom}::TIMESTAMPTZ AT TIME ZONE '${tz}')`;
+            }
+        }
+        const extracted = `EXTRACT(${units} FROM ${extractFrom})`;
+        return from.units === 'day_of_week' ? `mod(${extracted}+1,7)` : extracted;
+    }
+    sqlCast(qi, cast) {
+        const expr = cast.e.sql || '';
+        const op = `${cast.srcType}::${cast.dstType}`;
+        const tz = (0, dialect_1.qtz)(qi);
+        if (op === 'timestamp::date' && tz) {
+            const tstz = `${expr}::TIMESTAMPTZ`;
+            return `CAST((${tstz}) AT TIME ZONE '${tz}' AS DATE)`;
+        }
+        else if (op === 'date::timestamp' && tz) {
+            return `CAST((${expr})::TIMESTAMP AT TIME ZONE '${tz}' AS TIMESTAMP)`;
+        }
+        if (cast.srcType !== cast.dstType) {
+            const dstType = typeof cast.dstType === 'string'
+                ? this.malloyTypeToSQLType({ type: cast.dstType })
+                : cast.dstType.raw;
+            const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
+            return `${castFunc}(${expr} AS ${dstType})`;
+        }
+        return expr;
+    }
+    sqlRegexpMatch(df) {
+        return `${df.kids.expr.sql} ~ ${df.kids.regex.sql}`;
+    }
+    sqlLiteralTime(qi, lt) {
+        if (lt.dataType === 'date') {
+            return `DATE '${lt.literal}'`;
+        }
+        const tz = lt.timezone || (0, dialect_1.qtz)(qi);
+        if (tz) {
+            return `TIMESTAMPTZ '${lt.literal} ${tz}'::TIMESTAMP`;
+        }
+        return `TIMESTAMP '${lt.literal}'`;
+    }
+}
+exports.PostgresBase = PostgresBase;
+//# sourceMappingURL=pg_impl.js.map

package/dist/dialect/postgres/functions/greatest_and_least.js

@@ -34,9 +34,7 @@ const types = [
 function greatestOrLeast(fn) {
     return types.map(type => (0, util_1.overload)((0, util_1.minScalar)(type), [(0, util_1.params)('values', (0, util_1.anyExprType)(type))], 
     // We match BigQuery null behavior here -- if any argument is null, return null
-    [
-        (0, util_1.sqlFragment)('CASE WHEN NUM_NULLS(', (0, util_1.spread)((0, util_1.arg)('values')), `) > 0 THEN NULL ELSE ${fn}(`, (0, util_1.spread)((0, util_1.arg)('values')), ') END'),
-    ]));
+    (0, util_1.sql) `CASE WHEN NUM_NULLS(${(0, util_1.spread)((0, util_1.arg)('values'))}) > 0 THEN NULL ELSE ${fn}(${(0, util_1.spread)((0, util_1.arg)('values'))}) END`));
 }
 const fnGreatest = () => greatestOrLeast('GREATEST');
 exports.fnGreatest = fnGreatest;

package/dist/dialect/postgres/functions/string_agg.js

@@ -27,7 +27,7 @@ const util_1 = require("../../functions/util");
 function fnStringAgg() {
     const value = (0, util_1.makeParam)('value', (0, util_1.maxScalar)('string'));
     const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
-    const orderBy = { type: 'aggregate_order_by' };
+    const orderBy = { node: 'aggregate_order_by' };
     return [
         (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(${value.arg}, ','${orderBy})`, { supportsOrderBy: true }),
         (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(${value.arg}, ${separator.arg}${orderBy})`, { supportsOrderBy: true }),
@@ -37,7 +37,7 @@ exports.fnStringAgg = fnStringAgg;
 function fnStringAggDistinct() {
     const value = (0, util_1.makeParam)('value', (0, util_1.maxScalar)('string'));
     const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
-    const orderBy = { type: 'aggregate_order_by' };
+    const orderBy = { node: 'aggregate_order_by' };
     return [
         (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}, ','${orderBy})`, {
             isSymmetric: true,

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

@@ -1,7 +1,8 @@
-import { DateUnit, Expr, ExtractUnit, Sampling, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../../model/malloy_types';
+import { Sampling, FieldAtomicTypeDef, TimeDeltaExpr, TypecastExpr, MeasureTimeExpr } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
-import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
-export declare class PostgresDialect extends Dialect {
+import { DialectFieldList, QueryInfo } from '../dialect';
+import { PostgresBase } from '../pg_impl';
+export declare class PostgresDialect extends PostgresBase {
     name: string;
     defaultNumberType: string;
     defaultDecimalType: string;
@@ -42,14 +43,9 @@ export declare class PostgresDialect extends Dialect {
     sqlSelectAliasAsStruct(alias: string): string;
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
-    sqlNow(): 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(qi: QueryInfo, cast: TypecastFragment): Expr;
-    sqlRegexpMatch(expr: Expr, regexp: Expr): Expr;
-    sqlLiteralTime(qi: QueryInfo, timeString: string, type: TimeFieldType, timezone: string | undefined): string;
-    sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
+    sqlAlterTimeExpr(df: TimeDeltaExpr): string;
+    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
     sqlSumDistinct(key: string, value: string, funcName: string): string;
     sqlAggDistinct(key: string, values: string[], func: (valNames: string[]) => string): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;

package/dist/dialect/postgres/postgres.js

@@ -26,11 +26,7 @@ exports.PostgresDialect = void 0;
 const utils_1 = require("../../model/utils");
 const malloy_types_1 = require("../../model/malloy_types");
 const functions_1 = require("./functions");
-const dialect_1 = require("../dialect");
-const pgExtractionMap = {
-    'day_of_week': 'dow',
-    'day_of_year': 'doy',
-};
+const pg_impl_1 = require("../pg_impl");
 const pgMakeIntervalMap = {
     'year': 'years',
     'month': 'months',
@@ -73,7 +69,7 @@ const postgresToMalloyTypes = {
     'pg_ndistinct': { type: 'number', numberType: 'integer' },
     'varchar': { type: 'string' },
 };
-class PostgresDialect extends dialect_1.Dialect {
+class PostgresDialect extends pg_impl_1.PostgresBase {
     constructor() {
         super(...arguments);
         this.name = 'postgres';
@@ -243,99 +239,40 @@ class PostgresDialect extends dialect_1.Dialect {
     sqlCreateTableAsSelect(_tableName, _sql) {
         throw new Error('Not implemented Yet');
     }
-    sqlNow() {
-        return (0, malloy_types_1.mkExpr) `LOCALTIMESTAMP`;
-    }
-    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;
-        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(qi, from, units) {
-        const pgUnits = pgExtractionMap[units] || units;
-        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) {
+    sqlAlterTimeExpr(df) {
+        let timeframe = df.units;
+        let n = df.kids.delta.sql;
         if (timeframe === 'quarter') {
             timeframe = 'month';
-            n = (0, malloy_types_1.mkExpr) `${n}*3`;
+            n = `${n}*3`;
         }
-        const interval = (0, malloy_types_1.mkExpr) `make_interval(${pgMakeIntervalMap[timeframe]}=>${n})`;
-        return (0, malloy_types_1.mkExpr) `((${expr.value})${op}${interval})`;
-    }
-    sqlCast(qi, cast) {
-        const op = `${cast.srcType}::${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.srcType !== cast.dstType) {
-            const dstType = typeof cast.dstType === 'string'
-                ? this.malloyTypeToSQLType({ type: cast.dstType })
-                : cast.dstType.raw;
-            if (cast.safe) {
-                throw new Error("Postgres dialect doesn't support Safe Cast");
-            }
-            const castFunc = 'CAST';
-            return (0, malloy_types_1.mkExpr) `${castFunc}(${cast.expr} AS ${dstType})`;
+        else if (timeframe === 'week') {
+            timeframe = 'day';
+            n = `${n}*7`;
         }
-        return cast.expr;
+        const interval = `make_interval(${pgMakeIntervalMap[timeframe]}=>${n})`;
+        return `(${df.kids.base.sql})${df.op}${interval}`;
     }
-    sqlRegexpMatch(expr, regexp) {
-        return (0, malloy_types_1.mkExpr) `(${expr} ~ ${regexp})`;
-    }
-    sqlLiteralTime(qi, timeString, type, timezone) {
-        if (type === 'date') {
-            return `DATE '${timeString}'`;
-        }
-        const tz = timezone || (0, dialect_1.qtz)(qi);
-        if (tz) {
-            return `TIMESTAMPTZ '${timeString} ${tz}'::TIMESTAMP`;
+    sqlCast(qi, cast) {
+        if (cast.safe) {
+            throw new Error("Postgres dialect doesn't support Safe Cast");
         }
-        return `TIMESTAMP '${timeString}'`;
-    }
-    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'
-                ? (0, malloy_types_1.mkExpr) `FLOOR(${duration})`
-                : (0, malloy_types_1.mkExpr) `FLOOR((${duration})/${inSeconds[units].toString()}.0)`;
+        return super.sqlCast(qi, cast);
+    }
+    sqlMeasureTimeExpr(df) {
+        const from = df.kids.left;
+        const to = df.kids.right;
+        let lVal = from.sql;
+        let rVal = to.sql;
+        if (inSeconds[df.units]) {
+            lVal = `EXTRACT(EPOCH FROM ${lVal})`;
+            rVal = `EXTRACT(EPOCH FROM ${rVal})`;
+            const duration = `${rVal}-${lVal}`;
+            return df.units === 'second'
+                ? `FLOOR(${duration})`
+                : `FLOOR((${duration})/${inSeconds[df.units].toString()}.0)`;
         }
-        throw new Error(`Unknown or unhandled postgres time unit: ${units}`);
+        throw new Error(`Unknown or unhandled postgres time unit: ${df.units}`);
     }
     sqlSumDistinct(key, value, funcName) {
         // return `sum_distinct(list({key:${key}, val: ${value}}))`;

package/dist/dialect/snowflake/functions/string_agg.js

@@ -28,7 +28,7 @@ function fnStringAgg() {
     const value = (0, util_1.makeParam)('value', (0, util_1.maxScalar)('string'));
     const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
     const orderBy = {
-        type: 'aggregate_order_by',
+        node: 'aggregate_order_by',
         prefix: ' WITHIN GROUP(',
         suffix: ')',
     };
@@ -42,7 +42,7 @@ function fnStringAggDistinct() {
     const value = (0, util_1.makeParam)('value', (0, util_1.maxScalar)('string'));
     const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
     const orderBy = {
-        type: 'aggregate_order_by',
+        node: 'aggregate_order_by',
         prefix: ' WITHIN GROUP(',
         suffix: ')',
     };

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

@@ -1,4 +1,4 @@
-import { DateUnit, Expr, ExtractUnit, Sampling, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../../model/malloy_types';
+import { Sampling, FieldAtomicTypeDef, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, TimeLiteralNode, MeasureTimeExpr, RegexMatchExpr } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
 import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
 export declare class SnowflakeDialect extends Dialect {
@@ -43,15 +43,15 @@ export declare class SnowflakeDialect extends Dialect {
     sqlSelectAliasAsStruct(alias: string): string;
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlCreateTableAsSelect(tableName: string, sql: string): string;
-    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;
+    sqlTruncExpr(qi: QueryInfo, te: TimeTruncExpr): string;
+    sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
+    sqlAlterTimeExpr(df: TimeDeltaExpr): string;
     private atTz;
-    sqlNow(): Expr;
-    sqlCast(qi: QueryInfo, cast: TypecastFragment): Expr;
-    sqlLiteralTime(qi: QueryInfo, timeString: string, type: TimeFieldType, timezone: string | undefined): string;
-    sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
-    sqlRegexpMatch(expr: Expr, regexp: Expr): Expr;
+    sqlNowExpr(): string;
+    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlLiteralTime(qi: QueryInfo, lf: TimeLiteralNode): string;
+    sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
+    sqlRegexpMatch(compare: RegexMatchExpr): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
     sqlOrderBy(orderTerms: string[]): string;
     sqlLiteralString(literal: string): string;

package/dist/dialect/snowflake/snowflake.js

@@ -141,20 +141,11 @@ class SnowflakeDialect extends dialect_1.Dialect {
     }
     sqlUnnestAlias(source, alias, _fieldList, _needDistinctKey, isArray, _isInNestedPipeline) {
         if (isArray) {
-            // if (needDistinctKey) {
-            //   // return `LEFT JOIN UNNEST(ARRAY(( SELECT AS STRUCT row_number() over() as __row_id, value FROM UNNEST(${source}) value))) as ${alias}`;
-            // } else {
-            //   return `LEFT JOIN UNNEST(ARRAY((SELECT AS STRUCT value FROM unnest(${source}) value))) as ${alias}`;
-            // }
             return `,LATERAL FLATTEN(INPUT => ${source}) AS ${alias}_1, LATERAL (SELECT ${alias}_1.INDEX, object_construct('value', ${alias}_1.value) as value ) as ${alias}`;
         }
         else {
             // have to have a non empty row or it treats it like an inner join :barf-emoji:
             return `LEFT JOIN LATERAL FLATTEN(INPUT => ifnull(${source},[1])) AS ${alias}`;
-            //   return `LEFT JOIN UNNEST(ARRAY(( SELECT AS STRUCT row_number() over() as __row_id, * FROM UNNEST(${source})))) as ${alias}`;
-            // } else {
-            //   return `LEFT JOIN UNNEST(${source}) as ${alias}`;
-            // }
         }
     }
     /*
@@ -243,43 +234,43 @@ ${(0, utils_1.indent)(sql)}
 );
 `;
     }
-    sqlTrunc(qi, sqlTime, units) {
+    sqlTruncExpr(qi, te) {
         const tz = (0, dialect_1.qtz)(qi);
-        let truncThis = sqlTime.value;
-        if (tz && sqlTime.valueType === 'timestamp') {
-            truncThis = (0, malloy_types_1.mkExpr) `CONVERT_TIMEZONE('${tz}', ${truncThis})`;
+        let truncThis = te.e.sql;
+        if (tz && te.e.dataType === 'timestamp') {
+            truncThis = `CONVERT_TIMEZONE('${tz}',${truncThis})`;
         }
-        return (0, malloy_types_1.mkExpr) `DATE_TRUNC('${units}', ${truncThis})`;
+        return `DATE_TRUNC('${te.units}',${truncThis})`;
     }
-    sqlExtract(qi, from, units) {
-        const extractUnits = extractionMap[units] || units;
-        let extractFrom = from.value;
+    sqlTimeExtractExpr(qi, from) {
+        const extractUnits = extractionMap[from.units] || from.units;
+        let extractFrom = from.e.sql;
         const tz = (0, dialect_1.qtz)(qi);
-        if (tz && from.valueType === 'timestamp') {
-            extractFrom = (0, malloy_types_1.mkExpr) `CONVERT_TIMEZONE('${tz}', ${extractFrom})`;
+        if (tz && from.e.dataType === 'timestamp') {
+            extractFrom = `CONVERT_TIMEZONE('${tz}', ${extractFrom})`;
         }
-        const extracted = (0, malloy_types_1.mkExpr) `EXTRACT(${extractUnits} FROM ${extractFrom})`;
-        return extracted;
+        return `EXTRACT(${extractUnits} FROM ${extractFrom})`;
     }
-    sqlAlterTime(op, expr, n, timeframe) {
-        const interval = (0, malloy_types_1.mkExpr) `INTERVAL '${n} ${timeframe}'`;
-        return (0, malloy_types_1.mkExpr) `((${expr.value})${op}${interval})`;
+    sqlAlterTimeExpr(df) {
+        const interval = `INTERVAL '${df.kids.delta.sql} ${df.units}'`;
+        return `(${df.kids.base.sql})${df.op}${interval}`;
     }
-    atTz(expr, tz) {
+    atTz(sqlExpr, tz) {
         if (tz !== undefined) {
-            return (0, malloy_types_1.mkExpr) `(
-      TO_CHAR(${expr}::TIMESTAMP_NTZ, 'YYYY-MM-DD HH24:MI:SS.FF9') ||
+            return `(
+      TO_CHAR(${sqlExpr}::TIMESTAMP_NTZ, 'YYYY-MM-DD HH24:MI:SS.FF9') ||
       TO_CHAR(CONVERT_TIMEZONE('${tz}', '1970-01-01 00:00:00'), 'TZHTZM')
     )::TIMESTAMP_TZ`;
         }
-        return (0, malloy_types_1.mkExpr) `${expr}::TIMESTAMP_NTZ`;
+        return `${sqlExpr}::TIMESTAMP_NTZ`;
     }
-    sqlNow() {
-        return (0, malloy_types_1.mkExpr) `CURRENT_TIMESTAMP()`;
+    sqlNowExpr() {
+        return 'CURRENT_TIMESTAMP()';
     }
     sqlCast(qi, cast) {
+        const src = cast.e.sql || '';
         if (cast.srcType === cast.dstType) {
-            return cast.expr;
+            return src;
         }
         if (cast.safe && typeof cast.srcType !== 'string') {
             // safe cast is only supported for a few combinations of src -> dst types
@@ -291,35 +282,36 @@ ${(0, utils_1.indent)(sql)}
         const tz = (0, dialect_1.qtz)(qi);
         // casting timestamps and dates
         if (cast.dstType === 'date' && cast.srcType === 'timestamp') {
-            let castExpr = cast.expr;
+            let castExpr = src;
             if (tz) {
-                castExpr = (0, malloy_types_1.mkExpr) `CONVERT_TIMEZONE('${tz}', ${castExpr})`;
+                castExpr = `CONVERT_TIMEZONE('${tz}', ${castExpr})`;
             }
-            return (0, malloy_types_1.mkExpr) `TO_DATE(${castExpr})`;
+            return `TO_DATE(${castExpr})`;
         }
         else if (cast.dstType === 'timestamp' && cast.srcType === 'date') {
-            const retExpr = (0, malloy_types_1.mkExpr) `TO_TIMESTAMP(${cast.expr})`;
+            const retExpr = `TO_TIMESTAMP(${src})`;
             return this.atTz(retExpr, tz);
         }
         const dstType = typeof cast.dstType === 'string'
             ? this.malloyTypeToSQLType({ type: cast.dstType })
             : cast.dstType.raw;
         const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
-        return (0, malloy_types_1.mkExpr) `${castFunc}(${cast.expr} AS ${dstType})`;
+        return `${castFunc}(${src} AS ${dstType})`;
     }
-    sqlLiteralTime(qi, timeString, type, timezone) {
+    sqlLiteralTime(qi, lf) {
+        var _a;
         const tz = (0, dialect_1.qtz)(qi);
         // just making it explicit that timestring does not have timezone info
-        let ret = `'${timeString}'::TIMESTAMP_NTZ`;
+        let ret = `'${lf.literal}'::TIMESTAMP_NTZ`;
         // now do the hack to add timezone to a timestamp ntz
-        const targetTimeZone = timezone !== null && timezone !== void 0 ? timezone : tz;
+        const targetTimeZone = (_a = lf.timezone) !== null && _a !== void 0 ? _a : tz;
         if (targetTimeZone) {
             const targetTimeZoneSuffix = `TO_CHAR(CONVERT_TIMEZONE('${targetTimeZone}', '1970-01-01 00:00:00'), 'TZHTZM')`;
             const retTimeString = `TO_CHAR(${ret}, 'YYYY-MM-DD HH24:MI:SS.FF9')`;
             ret = `${retTimeString} || ${targetTimeZoneSuffix}`;
             ret = `(${ret})::TIMESTAMP_TZ`;
         }
-        switch (type) {
+        switch (lf.dataType) {
             case 'date':
                 return `TO_DATE(${ret})`;
             case 'timestamp': {
@@ -327,24 +319,25 @@ ${(0, utils_1.indent)(sql)}
             }
         }
     }
-    sqlMeasureTime(from, to, units) {
+    sqlMeasureTimeExpr(df) {
+        const from = df.kids.left;
+        const to = df.kids.right;
         let extractUnits = 'nanoseconds';
-        if (from.valueType === 'date' || to.valueType === 'date') {
+        if (from.dataType === 'date' || to.dataType === 'date') {
             extractUnits = 'seconds';
         }
-        return (0, malloy_types_1.mkExpr) `TIMESTAMPDIFF(
-      '${units}',
+        return `TIMESTAMPDIFF(
+      '${df.units}',
       '1970-01-01 00:00:00'::TIMESTAMP_NTZ,
       TIMESTAMPADD(
         '${extractUnits}',
-        EXTRACT('epoch_${extractUnits}', ${to.value}) - EXTRACT('epoch_${extractUnits}', ${from.value}),
+        EXTRACT('epoch_${extractUnits}', ${to.sql}) - EXTRACT('epoch_${extractUnits}', ${from.sql}),
         '1970-01-01 00:00:00'::TIMESTAMP_NTZ
       )
     )`;
     }
-    sqlRegexpMatch(expr, regexp) {
-        // regexp_match captures any partial match
-        return (0, malloy_types_1.mkExpr) `(REGEXP_INSTR(${expr}, ${regexp}) != 0)`;
+    sqlRegexpMatch(compare) {
+        return `REGEXP_INSTR(${compare.kids.expr.sql}, ${compare.kids.regex.sql}) != 0`;
     }
     sqlSampleTable(tableSQL, sample) {
         if (sample !== undefined) {

package/dist/dialect/standardsql/functions/string_agg.js

@@ -27,8 +27,8 @@ const util_1 = require("../../functions/util");
 function fnStringAgg() {
     const value = (0, util_1.makeParam)('value', (0, util_1.maxScalar)('string'));
     const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
-    const orderBy = { type: 'aggregate_order_by' };
-    const limit = { type: 'aggregate_limit' };
+    const orderBy = { node: 'aggregate_order_by' };
+    const limit = { node: 'aggregate_limit' };
     return [
         (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(${value.arg}${orderBy}${limit})`, { supportsOrderBy: true, supportsLimit: true, defaultOrderByArgIndex: 0 }),
         (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(${value.arg}, ${separator.arg}${orderBy}${limit})`, { supportsOrderBy: true, supportsLimit: true, defaultOrderByArgIndex: 0 }),
@@ -38,8 +38,8 @@ exports.fnStringAgg = fnStringAgg;
 function fnStringAggDistinct() {
     const value = (0, util_1.makeParam)('value', (0, util_1.maxScalar)('string'));
     const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
-    const orderBy = { type: 'aggregate_order_by' };
-    const limit = { type: 'aggregate_limit' };
+    const orderBy = { node: 'aggregate_order_by' };
+    const limit = { node: 'aggregate_limit' };
     return [
         (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}${orderBy}${limit})`, {
             isSymmetric: true,

package/dist/dialect/standardsql/standardsql.d.ts

@@ -1,4 +1,4 @@
-import { Expr, ExtractUnit, Sampling, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../../model/malloy_types';
+import { Sampling, FieldAtomicTypeDef, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, MeasureTimeExpr } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
 import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
 export declare class StandardSQLDialect extends Dialect {
@@ -41,15 +41,15 @@ export declare class StandardSQLDialect extends Dialect {
     sqlSelectAliasAsStruct(alias: string): string;
     keywords: string[];
     sqlMaybeQuoteIdentifier(identifier: string): string;
-    sqlNow(): 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;
+    sqlNowExpr(): string;
+    sqlTruncExpr(qi: QueryInfo, trunc: TimeTruncExpr): string;
+    sqlTimeExtractExpr(qi: QueryInfo, te: TimeExtractExpr): string;
+    sqlAlterTimeExpr(df: TimeDeltaExpr): string;
     ignoreInProject(fieldName: string): boolean;
-    sqlCast(qi: QueryInfo, cast: TypecastFragment): Expr;
-    sqlRegexpMatch(expr: Expr, regexp: Expr): Expr;
-    sqlLiteralTime(qi: QueryInfo, timeString: string, type: 'date' | 'timestamp', timezone: string | undefined): string;
-    sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
+    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlRegexpMatch(match: RegexMatchExpr): string;
+    sqlLiteralTime(qi: QueryInfo, lit: TimeLiteralNode): string;
+    sqlMeasureTimeExpr(measure: MeasureTimeExpr): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
     sqlLiteralString(literal: string): string;
     sqlLiteralRegexp(literal: string): string;