@malloydata/malloy 0.0.177-dev240828173040 → 0.0.177-dev240829030921

package/dist/dialect/standardsql/standardsql.js

@@ -300,46 +300,48 @@ ${(0, utils_1.indent)(sql)}
         //   : identifier;
         return '`' + identifier + '`';
     }
-    sqlNow() {
-        return (0, malloy_types_1.mkExpr) `CURRENT_TIMESTAMP()`;
+    sqlNowExpr() {
+        return 'CURRENT_TIMESTAMP()';
     }
-    sqlTrunc(qi, sqlTime, units) {
+    sqlTruncExpr(qi, trunc) {
         const tz = qtz(qi);
         const tzAdd = tz ? `, "${tz}"` : '';
-        if (sqlTime.valueType === 'date') {
-            if (dateMeasureable(units)) {
-                return (0, malloy_types_1.mkExpr) `DATE_TRUNC(${sqlTime.value},${units})`;
+        if (trunc.e.dataType === 'date') {
+            if (dateMeasureable(trunc.units)) {
+                return `DATE_TRUNC(${trunc.e.sql},${trunc.units})`;
             }
-            return (0, malloy_types_1.mkExpr) `TIMESTAMP(${sqlTime.value}${tzAdd})`;
+            return `TIMESTAMP(${trunc.e.sql}${tzAdd})`;
         }
-        return (0, malloy_types_1.mkExpr) `TIMESTAMP_TRUNC(${sqlTime.value},${units}${tzAdd})`;
+        return `TIMESTAMP_TRUNC(${trunc.e.sql},${trunc.units}${tzAdd})`;
     }
-    sqlExtract(qi, expr, units) {
-        const extractTo = extractMap[units] || units;
-        const tz = expr.valueType === 'timestamp' && qtz(qi);
+    sqlTimeExtractExpr(qi, te) {
+        const extractTo = extractMap[te.units] || te.units;
+        const tz = te.e.dataType === 'timestamp' && qtz(qi);
         const tzAdd = tz ? ` AT TIME ZONE '${tz}'` : '';
-        return (0, malloy_types_1.mkExpr) `EXTRACT(${extractTo} FROM ${expr.value}${tzAdd})`;
+        return `EXTRACT(${extractTo} FROM ${te.e.sql}${tzAdd})`;
     }
-    sqlAlterTime(op, expr, n, timeframe) {
-        let theTime = expr.value;
-        let computeType = expr.valueType;
-        if (timeframe !== 'day' && timestampMeasureable(timeframe)) {
+    sqlAlterTimeExpr(df) {
+        const from = df.kids.base;
+        let dataType = from.dataType;
+        let sql = from.sql;
+        if (df.units !== 'day' && timestampMeasureable(df.units)) {
             // The units must be done in timestamp, no matter the input type
-            computeType = 'timestamp';
-            if (expr.valueType !== 'timestamp') {
-                theTime = (0, malloy_types_1.mkExpr) `TIMESTAMP(${theTime})`;
+            if (dataType !== 'timestamp') {
+                sql = `TIMESTAMP(${sql})`;
+                dataType = 'timestamp';
             }
         }
-        else if (expr.valueType === 'timestamp') {
-            theTime = (0, malloy_types_1.mkExpr) `DATETIME(${theTime})`;
-            computeType = 'datetime';
+        else if (dataType === 'timestamp') {
+            sql = `DATETIME(${sql})`;
+            dataType = 'datetime';
         }
-        const funcName = computeType.toUpperCase() + (op === '+' ? '_ADD' : '_SUB');
-        const newTime = (0, malloy_types_1.mkExpr) `${funcName}(${theTime}, INTERVAL ${n} ${timeframe})`;
-        if (computeType === expr.valueType) {
+        const funcTail = df.op === '+' ? '_ADD' : '_SUB';
+        const funcName = `${dataType.toUpperCase()}${funcTail}`;
+        const newTime = `${funcName}(${sql}, INTERVAL ${df.kids.delta.sql} ${df.units})`;
+        if (dataType === from.dataType) {
             return newTime;
         }
-        return (0, malloy_types_1.mkExpr) `${expr.valueType.toUpperCase()}(${newTime})`;
+        return `${from.dataType.toUpperCase()}(${newTime})`;
     }
     ignoreInProject(fieldName) {
         return fieldName === '_PARTITIONTIME';
@@ -347,41 +349,42 @@ ${(0, utils_1.indent)(sql)}
     sqlCast(qi, cast) {
         const op = `${cast.srcType}::${cast.dstType}`;
         const tz = qtz(qi);
+        const src = cast.e.sql || '';
         if (op === 'timestamp::date' && tz) {
-            return (0, malloy_types_1.mkExpr) `DATE(${cast.expr},'${tz}')`;
+            return `DATE(${src},'${tz}')`;
         }
         if (op === 'date::timestamp' && tz) {
-            return (0, malloy_types_1.mkExpr) `TIMESTAMP(${cast.expr}, '${tz}')`;
+            return `TIMESTAMP(${src}, '${tz}')`;
         }
         if (cast.srcType !== cast.dstType) {
             const dstType = typeof cast.dstType === 'string'
                 ? this.malloyTypeToSQLType({ type: cast.dstType })
                 : cast.dstType.raw;
             const castFunc = cast.safe ? 'SAFE_CAST' : 'CAST';
-            return (0, malloy_types_1.mkExpr) `${castFunc}(${cast.expr} AS ${dstType})`;
+            return `${castFunc}(${src} AS ${dstType})`;
         }
-        return cast.expr;
+        return src;
     }
-    sqlRegexpMatch(expr, regexp) {
-        return (0, malloy_types_1.mkExpr) `REGEXP_CONTAINS(${expr}, ${regexp})`;
+    sqlRegexpMatch(match) {
+        return `REGEXP_CONTAINS(${match.kids.expr.sql},${match.kids.regex.sql})`;
     }
-    sqlLiteralTime(qi, timeString, type, timezone) {
-        if (type === 'date') {
-            return `DATE('${timeString}')`;
+    sqlLiteralTime(qi, lit) {
+        if (lit.dataType === 'date') {
+            return `DATE('${lit.literal}')`;
         }
-        else if (type === 'timestamp') {
-            let timestampArgs = `'${timeString}'`;
-            const tz = timezone || qtz(qi);
+        else if (lit.dataType === 'timestamp') {
+            let timestampArgs = `'${lit.literal}'`;
+            const tz = lit.timezone || qtz(qi);
             if (tz && tz !== 'UTC') {
                 timestampArgs += `,'${tz}'`;
             }
             return `TIMESTAMP(${timestampArgs})`;
         }
         else {
-            throw new Error(`Unsupported Literal time format ${type}`);
+            throw new Error(`Unsupported Literal time format ${lit.dataType}`);
         }
     }
-    sqlMeasureTime(from, to, units) {
+    sqlMeasureTimeExpr(measure) {
         const measureMap = {
             'microsecond': { use: 'microsecond', ratio: 1 },
             'millisecond': { use: 'microsecond', ratio: 1000 },
@@ -391,27 +394,29 @@ ${(0, utils_1.indent)(sql)}
             'day': { use: 'hour', ratio: 24 },
             'week': { use: 'day', ratio: 7 },
         };
-        let lVal = from.value;
-        let rVal = to.value;
-        if (measureMap[units]) {
-            const { use: measureIn, ratio } = measureMap[units];
+        const from = measure.kids.left;
+        const to = measure.kids.right;
+        let lVal = from.sql;
+        let rVal = to.sql;
+        if (measureMap[measure.units]) {
+            const { use: measureIn, ratio } = measureMap[measure.units];
             if (!timestampMeasureable(measureIn)) {
                 throw new Error(`Measure in '${measureIn} not implemented`);
             }
-            if (from.valueType !== to.valueType) {
+            if (from.dataType !== to.dataType) {
                 throw new Error("Can't measure difference between different types");
             }
-            if (from.valueType === 'date') {
-                lVal = (0, malloy_types_1.mkExpr) `TIMESTAMP(${lVal})`;
-                rVal = (0, malloy_types_1.mkExpr) `TIMESTAMP(${rVal})`;
+            if (from.dataType === 'date') {
+                lVal = `TIMESTAMP(${lVal})`;
+                rVal = `TIMESTAMP(${rVal})`;
             }
-            let measured = (0, malloy_types_1.mkExpr) `TIMESTAMP_DIFF(${rVal},${lVal},${measureIn})`;
+            let measured = `TIMESTAMP_DIFF(${rVal},${lVal},${measureIn})`;
             if (ratio !== 1) {
-                measured = (0, malloy_types_1.mkExpr) `FLOOR(${measured}/${ratio.toString()}.0)`;
+                measured = `FLOOR(${measured}/${ratio.toString()}.0)`;
             }
             return measured;
         }
-        throw new Error(`Measure '${units} not implemented`);
+        throw new Error(`Measure '${measure.units} not implemented`);
     }
     sqlSampleTable(tableSQL, sample) {
         if (sample !== undefined) {

package/dist/dialect/trino/functions/concat.js

@@ -28,7 +28,7 @@ function fnConcat() {
     return [
         // TODO: in DuckDB and Postgres, nulls are treated like "",
         // but in BigQuery and Snowflake, nulls propagate and the result becomes null
-        (0, util_1.overload)((0, util_1.minScalar)('string'), [], [{ type: 'dialect', function: 'stringLiteral', literal: '' }]),
+        (0, util_1.overload)((0, util_1.minScalar)('string'), [], { node: 'stringLiteral', literal: '' }),
         (0, util_1.overload)((0, util_1.minScalar)('string'), [
             (0, util_1.params)('values', (0, util_1.anyExprType)('string'), (0, util_1.anyExprType)('number'), (0, util_1.anyExprType)('date'), (0, util_1.anyExprType)('timestamp'), (0, util_1.anyExprType)('boolean')),
         ], (0, util_1.sql) `CONCAT(${(0, util_1.spread)((0, util_1.arg)('values'), 'CAST(', 'AS VARCHAR)')})`),

package/dist/dialect/trino/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: '',
         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: '',
         suffix: '',
     };

package/dist/dialect/trino/trino.d.ts

@@ -1,7 +1,8 @@
-import { Expr, ExtractUnit, Sampling, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef, DialectFragment, DateUnit, TimeFieldType } from '../../model/malloy_types';
+import { Expr, Sampling, FieldAtomicTypeDef, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeLiteralNode, TimeExtractExpr } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
-import { Dialect, DialectFieldList, OrderByClauseType, QueryInfo } from '../dialect';
-export declare class TrinoDialect extends Dialect {
+import { DialectFieldList, OrderByClauseType, QueryInfo } from '../dialect';
+import { PostgresBase } from '../pg_impl';
+export declare class TrinoDialect extends PostgresBase {
     name: string;
     experimental: boolean;
     defaultNumberType: string;
@@ -30,7 +31,7 @@ export declare class TrinoDialect extends Dialect {
     supportsCountApprox: boolean;
     quoteTablePath(tablePath: string): string;
     sqlGroupSetTable(groupSetCount: number): string;
-    dialectExpr(qi: QueryInfo, df: DialectFragment): Expr;
+    exprToSQL(qi: QueryInfo, df: Expr): string | undefined;
     sqlAnyValue(groupSet: number, fieldName: string): string;
     buildTypeExpression(fieldList: DialectFieldList): string;
     sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined, limit: number | undefined): string;
@@ -50,14 +51,10 @@ export declare class TrinoDialect extends Dialect {
     sqlSelectAliasAsStruct(alias: string, fieldList: any): string;
     keywords: string[];
     sqlMaybeQuoteIdentifier(identifier: 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;
+    sqlRegexpMatch(reCmp: RegexMatchExpr): string;
+    sqlMeasureTimeExpr(mf: MeasureTimeExpr): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
     sqlLiteralString(literal: string): string;
     sqlLiteralRegexp(literal: string): string;
@@ -69,6 +66,8 @@ export declare class TrinoDialect extends Dialect {
     sqlMakeUnnestKey(key: string, rowKey: string): string;
     sqlStringAggDistinct(distinctKey: string, valueSQL: string, separatorSQL: string): string;
     validateTypeName(sqlType: string): boolean;
+    sqlLiteralTime(qi: QueryInfo, lit: TimeLiteralNode): string;
+    sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
 }
 export declare class PrestoDialect extends TrinoDialect {
     name: string;

package/dist/dialect/trino/trino.js

@@ -27,6 +27,7 @@ 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 pg_impl_1 = require("../pg_impl");
 // These are the units that "TIMESTAMP_ADD" "TIMESTAMP_DIFF" accept
 function timestampMeasureable(units) {
     return [
@@ -38,10 +39,6 @@ function timestampMeasureable(units) {
         'day',
     ].includes(units);
 }
-const pgExtractionMap = {
-    'day_of_week': 'dow',
-    'day_of_year': 'doy',
-};
 /**
  * Return a non UTC timezone, if one was specificed.
  */
@@ -55,7 +52,7 @@ const trinoTypeMap = {
     'string': 'VARCHAR',
     'number': 'DOUBLE',
 };
-class TrinoDialect extends dialect_1.Dialect {
+class TrinoDialect extends pg_impl_1.PostgresBase {
     constructor() {
         super(...arguments);
         this.name = 'trino';
@@ -188,13 +185,12 @@ class TrinoDialect extends dialect_1.Dialect {
     sqlGroupSetTable(groupSetCount) {
         return `CROSS JOIN (SELECT row_number() OVER() -1  group_set FROM UNNEST(SEQUENCE(0,${groupSetCount})))`;
     }
-    dialectExpr(qi, df) {
-        switch (df.function) {
-            case 'div': {
-                return (0, malloy_types_1.mkExpr) `CAST(${df.numerator} AS DOUBLE)/${df.denominator}`;
-            }
+    exprToSQL(qi, df) {
+        switch (df.node) {
+            case '/':
+                return `CAST(${df.kids.left.sql} AS DOUBLE)/${df.kids.right.sql}`;
         }
-        return super.dialectExpr(qi, df);
+        return super.exprToSQL(qi, df);
     }
     sqlAnyValue(groupSet, fieldName) {
         return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN ${fieldName} END)`;
@@ -327,90 +323,46 @@ ${(0, utils_1.indent)(sql)}
     sqlMaybeQuoteIdentifier(identifier) {
         return '"' + identifier + '"';
     }
-    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) `DATE_ADD('day', 1, ${sqlTime.value})`
-            : sqlTime.value;
-        if (sqlTime.valueType === 'timestamp') {
-            const tz = qtz(qi);
-            if (tz) {
-                const civilSource = (0, malloy_types_1.mkExpr) `AT_TIMEZONE(${truncThis},'${tz}')`;
-                const civilTrunc = (0, malloy_types_1.mkExpr) `DATE_TRUNC('${units}', ${civilSource})`;
-                // MTOY todo ... only need to do this if this is a date ...
-                return (0, malloy_types_1.mkExpr) `AT_TIMEZONE(${civilTrunc},'${tz}')`;
-                // return mkExpr`CAST((${truncTsTz}),TIMESTAMP)`;
-            }
-        }
-        let result = (0, malloy_types_1.mkExpr) `DATE_TRUNC('${units}', ${truncThis})`;
-        if (week) {
-            result = (0, malloy_types_1.mkExpr) `DATE_ADD('day',-1, ${result})`;
-        }
-        return result;
-    }
-    sqlExtract(qi, from, units) {
-        const pgUnits = pgExtractionMap[units] || units;
-        let extractFrom = from.value;
-        if (from.valueType === 'timestamp') {
-            const tz = qtz(qi);
-            if (tz) {
-                extractFrom = (0, malloy_types_1.mkExpr) `at_timezone(${extractFrom},'${tz}')`;
-            }
-        }
-        const extracted = (0, malloy_types_1.mkExpr) `EXTRACT(${pgUnits} FROM ${extractFrom})`;
-        return units === 'day_of_week' ? (0, malloy_types_1.mkExpr) `mod(${extracted}+1,7)` : 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`;
         }
         if (timeframe === 'week') {
             timeframe = 'day';
-            n = (0, malloy_types_1.mkExpr) `${n}*7`;
+            n = `${n}*7`;
         }
-        if (op === '-') {
-            n = (0, malloy_types_1.mkExpr) `(${n})*-1`;
+        if (df.op === '-') {
+            n = `(${n})*-1`;
         }
-        return (0, malloy_types_1.mkExpr) `DATE_ADD('${timeframe}', ${n}, ${expr.value})`;
+        return `DATE_ADD('${timeframe}', ${n}, ${df.kids.base.sql})`;
     }
     sqlCast(qi, cast) {
         const op = `${cast.srcType}=>${cast.dstType}`;
         const tz = qtz(qi);
+        const expr = cast.e.sql || '';
         if (op === 'timestamp=>date' && tz) {
-            const tstz = (0, malloy_types_1.mkExpr) `CAST(${cast.expr} as TIMESTAMP)`;
-            return (0, malloy_types_1.mkExpr) `CAST((${tstz}) AT TIME ZONE '${tz}' AS DATE)`;
+            const tstz = `CAST(${expr} as TIMESTAMP)`;
+            return `CAST((${tstz}) AT TIME ZONE '${tz}' AS DATE)`;
         }
         else if (op === 'date=>timestamp' && tz) {
-            return (0, malloy_types_1.mkExpr) `CAST(CONCAT(CAST(CAST(${cast.expr} AS TIMESTAMP) AS VARCHAR), ' ${tz}') AS TIMESTAMP WITH TIME ZONE)`;
+            return `CAST(CONCAT(CAST(CAST(${expr} AS TIMESTAMP) AS VARCHAR), ' ${tz}') AS TIMESTAMP WITH TIME ZONE)`;
         }
         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 (0, malloy_types_1.mkExpr) `${castFunc}(${cast.expr} AS ${dstType})`;
+            return `${castFunc}(${expr} AS ${dstType})`;
         }
-        return cast.expr;
+        return expr;
     }
-    sqlRegexpMatch(expr, regexp) {
-        return (0, malloy_types_1.mkExpr) `REGEXP_LIKE(${expr}, ${regexp})`;
+    sqlRegexpMatch(reCmp) {
+        return `REGEXP_LIKE(${reCmp.kids.expr.sql}, ${reCmp.kids.regex.sql})`;
     }
-    sqlLiteralTime(qi, timeString, type, timezone) {
-        if (type === 'date') {
-            return `DATE '${timeString}'`;
-        }
-        const tz = timezone || qtz(qi);
-        if (tz) {
-            return `TIMESTAMP '${timeString} ${tz}'`;
-        }
-        return `TIMESTAMP '${timeString}'`;
-    }
-    sqlMeasureTime(from, to, units) {
+    sqlMeasureTimeExpr(mf) {
         const measureMap = {
             'microsecond': { use: 'microsecond', ratio: 1 },
             'millisecond': { use: 'microsecond', ratio: 1000 },
@@ -420,27 +372,29 @@ ${(0, utils_1.indent)(sql)}
             'day': { use: 'hour', ratio: 24 },
             'week': { use: 'day', ratio: 7 },
         };
-        let lVal = from.value;
-        let rVal = to.value;
-        if (measureMap[units]) {
-            const { use: measureIn, ratio } = measureMap[units];
+        const from = mf.kids.left;
+        const to = mf.kids.right;
+        let lVal = from.sql;
+        let rVal = to.sql;
+        if (measureMap[mf.units]) {
+            const { use: measureIn, ratio } = measureMap[mf.units];
             if (!timestampMeasureable(measureIn)) {
                 throw new Error(`Measure in '${measureIn} not implemented`);
             }
-            if (from.valueType !== to.valueType) {
+            if (from.dataType !== to.dataType) {
                 throw new Error("Can't measure difference between different types");
             }
-            if (from.valueType === 'date') {
-                lVal = (0, malloy_types_1.mkExpr) `CAST(${lVal} AS TIMESTAMP)`;
-                rVal = (0, malloy_types_1.mkExpr) `CAST(${rVal} AS TIMESTAMP)`;
+            if (from.dataType === 'date') {
+                lVal = `CAST(${lVal} AS TIMESTAMP)`;
+                rVal = `CAST(${rVal} AS TIMESTAMP)`;
             }
-            let measured = (0, malloy_types_1.mkExpr) `DATE_DIFF('${measureIn}',${lVal},${rVal})`;
+            let measured = `DATE_DIFF('${measureIn}',${lVal},${rVal})`;
             if (ratio !== 1) {
-                measured = (0, malloy_types_1.mkExpr) `FLOOR(CAST(${measured} AS DOUBLE)/${ratio.toString()}.0)`;
+                measured = `FLOOR(CAST(${measured} AS DOUBLE)/${ratio.toString()}.0)`;
             }
             return measured;
         }
-        throw new Error(`Measure '${units} not implemented`);
+        throw new Error(`Measure '${mf.units} not implemented`);
     }
     sqlSampleTable(tableSQL, sample) {
         if (sample !== undefined) {
@@ -505,6 +459,28 @@ ${(0, utils_1.indent)(sql)}
         // Angle Brackets:       ARRAY<INT64>
         return sqlType.match(/^[A-Za-z\s(),<>0-9]*$/) !== null;
     }
+    sqlLiteralTime(qi, lit) {
+        if (lit.dataType === 'date') {
+            return `DATE '${lit.literal}'`;
+        }
+        const tz = lit.timezone || qtz(qi);
+        if (tz) {
+            return `TIMESTAMP '${lit.literal} ${tz}'`;
+        }
+        return `TIMESTAMP '${lit.literal}'`;
+    }
+    sqlTimeExtractExpr(qi, from) {
+        const pgUnits = pg_impl_1.timeExtractMap[from.units] || from.units;
+        let extractFrom = from.e.sql || '';
+        if (from.e.dataType === 'timestamp') {
+            const tz = qtz(qi);
+            if (tz) {
+                extractFrom = `at_timezone(${extractFrom},'${tz}')`;
+            }
+        }
+        const extracted = `EXTRACT(${pgUnits} FROM ${extractFrom})`;
+        return from.units === 'day_of_week' ? `mod(${extracted}+1,7)` : extracted;
+    }
 }
 exports.TrinoDialect = TrinoDialect;
 TrinoDialect.dtype = 'DECIMAL(38,0)';

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export { DuckDBDialect, StandardSQLDialect, PostgresDialect, SnowflakeDialect, registerDialect, arg, qtz, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, sqlFragment, param, params, literal, spread, Dialect, FUNCTIONS, } from './dialect';
+export { DuckDBDialect, StandardSQLDialect, PostgresDialect, SnowflakeDialect, registerDialect, arg, qtz, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, param, params, literal, spread, Dialect, FUNCTIONS, } from './dialect';
 export type { DialectFieldList, DialectFunctionOverloadDef, QueryInfo, } from './dialect';
-export type { QueryDataRow, Fragment, StructDef, StructRelationship, NamedStructDefs, MalloyQueryData, AtomicFieldType as AtomicFieldTypeInner, DateUnit, ExtractUnit, TimestampUnit, TimeFieldType, QueryData, QueryValue, FieldTypeDef, Expr, DialectFragment, TimeValue, FilterExpression, SQLBlock, FieldAtomicDef, FieldDef, PipeSegment, QueryFieldDef, IndexFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryResult, QueryRunStats, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FieldValueType, ExpressionTypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, TypecastFragment, Annotation, FieldAtomicTypeDef, SQLBlockStructDef, } from './model';
-export { Segment, isSamplingEnable, isSamplingPercent, isSamplingRows, mkExpr, expressionIsCalculation, indent, } from './model';
+export type { QueryDataRow, StructDef, StructRelationship, NamedStructDefs, MalloyQueryData, AtomicFieldType as AtomicFieldTypeInner, DateUnit, ExtractUnit, TimestampUnit, TimeFieldType, QueryData, QueryValue, FieldTypeDef, Expr, FilterCondition, SQLBlock, FieldAtomicDef, FieldDef, PipeSegment, QueryFieldDef, IndexFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryResult, QueryRunStats, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FieldValueType, ExpressionTypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, FieldAtomicTypeDef, SQLBlockStructDef, } from './model';
+export { Segment, isSamplingEnable, isSamplingPercent, isSamplingRows, expressionIsCalculation, indent, composeSQLExpr, } from './model';
 export { MalloyTranslator, } from './lang';
 export type { LogMessage, TranslateResponse } from './lang';
 export { Model, Malloy, Runtime, AtomicFieldType, ConnectionRuntime, SingleConnectionRuntime, EmptyURLReader, InMemoryURLReader, FixedConnectionMap, MalloyError, JoinRelationship, SourceRelationship, DateTimeframe, TimestampTimeframe, PreparedResult, Result, QueryMaterializer, CSVWriter, JSONWriter, Parse, DataWriter, Explore, } from './malloy';

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.Model = exports.MalloyTranslator = exports.indent = exports.expressionIsCalculation = exports.mkExpr = exports.isSamplingRows = exports.isSamplingPercent = exports.isSamplingEnable = exports.Segment = exports.FUNCTIONS = exports.Dialect = exports.spread = exports.literal = exports.params = exports.param = exports.sqlFragment = exports.makeParam = exports.sql = exports.maxScalar = exports.minAggregate = exports.anyExprType = exports.minScalar = exports.overload = exports.qtz = exports.arg = exports.registerDialect = exports.SnowflakeDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
-exports.Tag = exports.toAsyncGenerator = exports.Explore = void 0;
+exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.Model = exports.MalloyTranslator = exports.composeSQLExpr = exports.indent = exports.expressionIsCalculation = exports.isSamplingRows = exports.isSamplingPercent = exports.isSamplingEnable = exports.Segment = exports.FUNCTIONS = exports.Dialect = exports.spread = exports.literal = exports.params = exports.param = exports.makeParam = exports.sql = exports.maxScalar = exports.minAggregate = exports.anyExprType = exports.minScalar = exports.overload = exports.qtz = exports.arg = exports.registerDialect = exports.SnowflakeDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
+exports.Tag = exports.toAsyncGenerator = void 0;
 /*
  * Copyright 2023 Google LLC
  *
@@ -39,7 +39,6 @@ Object.defineProperty(exports, "minAggregate", { enumerable: true, get: function
 Object.defineProperty(exports, "maxScalar", { enumerable: true, get: function () { return dialect_1.maxScalar; } });
 Object.defineProperty(exports, "sql", { enumerable: true, get: function () { return dialect_1.sql; } });
 Object.defineProperty(exports, "makeParam", { enumerable: true, get: function () { return dialect_1.makeParam; } });
-Object.defineProperty(exports, "sqlFragment", { enumerable: true, get: function () { return dialect_1.sqlFragment; } });
 Object.defineProperty(exports, "param", { enumerable: true, get: function () { return dialect_1.param; } });
 Object.defineProperty(exports, "params", { enumerable: true, get: function () { return dialect_1.params; } });
 Object.defineProperty(exports, "literal", { enumerable: true, get: function () { return dialect_1.literal; } });
@@ -52,9 +51,9 @@ Object.defineProperty(exports, "Segment", { enumerable: true, get: function () {
 Object.defineProperty(exports, "isSamplingEnable", { enumerable: true, get: function () { return model_1.isSamplingEnable; } });
 Object.defineProperty(exports, "isSamplingPercent", { enumerable: true, get: function () { return model_1.isSamplingPercent; } });
 Object.defineProperty(exports, "isSamplingRows", { enumerable: true, get: function () { return model_1.isSamplingRows; } });
-Object.defineProperty(exports, "mkExpr", { enumerable: true, get: function () { return model_1.mkExpr; } });
 Object.defineProperty(exports, "expressionIsCalculation", { enumerable: true, get: function () { return model_1.expressionIsCalculation; } });
 Object.defineProperty(exports, "indent", { enumerable: true, get: function () { return model_1.indent; } });
+Object.defineProperty(exports, "composeSQLExpr", { enumerable: true, get: function () { return model_1.composeSQLExpr; } });
 var lang_1 = require("./lang");
 // Needed for tests only
 Object.defineProperty(exports, "MalloyTranslator", { enumerable: true, get: function () { return lang_1.MalloyTranslator; } });

package/dist/lang/ast/ast-utils.d.ts

@@ -5,6 +5,6 @@ import { ExprValue } from './types/expr-value';
  * generated SQL will have a reference to an impossible variable name
  * with the reason embedded in it.
  * @param reason very short phrase, only read by implementers
- * @return Fragment[] which a debugging humnan will regognize
+ * @return Expr which a debugging humnan will regognize
  */
 export declare function errorFor(reason: string): ExprValue;

package/dist/lang/ast/ast-utils.js

@@ -29,13 +29,13 @@ exports.errorFor = void 0;
  * generated SQL will have a reference to an impossible variable name
  * with the reason embedded in it.
  * @param reason very short phrase, only read by implementers
- * @return Fragment[] which a debugging humnan will regognize
+ * @return Expr which a debugging humnan will regognize
  */
 function errorFor(reason) {
     return {
         dataType: 'error',
         expressionType: 'scalar',
-        value: [`_ERROR_${reason.replace(/ /g, '_')}`],
+        value: { node: 'error', message: reason },
         evalSpace: 'constant',
     };
 }

package/dist/lang/ast/expressions/apply.js

@@ -23,13 +23,12 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Apply = void 0;
-const comparison_1 = require("../types/comparison");
 const expr_compare_1 = require("./expr-compare");
 const granular_result_1 = require("../types/granular-result");
 const expr_granular_time_1 = require("./expr-granular-time");
 class Apply extends expr_compare_1.ExprCompare {
     constructor(left, right) {
-        super(left, comparison_1.Comparison.EqualTo, right);
+        super(left, '=', right);
         this.left = left;
         this.right = right;
         this.elementType = 'apply';

package/dist/lang/ast/expressions/binary-boolean.d.ts

@@ -1,7 +1,8 @@
+import { BinaryMalloyOperator } from '../types/binary_operators';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
-export declare abstract class BinaryBoolean<opType extends string> extends ExpressionDef {
+export declare abstract class BinaryBoolean<opType extends BinaryMalloyOperator> extends ExpressionDef {
     readonly left: ExpressionDef;
     readonly op: opType;
     readonly right: ExpressionDef;

package/dist/lang/ast/expressions/binary-boolean.js

@@ -26,11 +26,11 @@ exports.BinaryBoolean = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const ast_utils_1 = require("../ast-utils");
 const fragtype_utils_1 = require("../fragtype-utils");
+const binary_operators_1 = require("../types/binary_operators");
 const expression_def_1 = require("../types/expression-def");
-const utils_1 = require("./utils");
 class BinaryBoolean extends expression_def_1.ExpressionDef {
     constructor(left, op, right) {
-        super({ left: left, right: right });
+        super({ left, right });
         this.left = left;
         this.op = op;
         this.right = right;
@@ -45,8 +45,11 @@ class BinaryBoolean extends expression_def_1.ExpressionDef {
             return {
                 dataType: 'boolean',
                 expressionType: (0, malloy_types_1.maxExpressionType)(left.expressionType, right.expressionType),
+                value: {
+                    node: (0, binary_operators_1.getExprNode)(this.op),
+                    kids: { left: left.value, right: right.value },
+                },
                 evalSpace,
-                value: (0, utils_1.compose)(left.value, this.op, right.value),
             };
         }
         return (0, ast_utils_1.errorFor)('logial required boolean');

package/dist/lang/ast/expressions/binary-numeric.d.ts

@@ -1,7 +1,8 @@
+import { ArithmeticMalloyOperator } from '../types/binary_operators';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
-export declare abstract class BinaryNumeric<opType extends string> extends ExpressionDef {
+export declare abstract class BinaryNumeric<opType extends ArithmeticMalloyOperator> extends ExpressionDef {
     readonly left: ExpressionDef;
     readonly op: opType;
     readonly right: ExpressionDef;

package/dist/lang/ast/expressions/boolean.js

@@ -32,7 +32,7 @@ class Boolean extends expression_def_1.ExpressionDef {
         this.elementType = 'boolean literal';
     }
     getExpression() {
-        return { ...fragtype_utils_1.FT.boolT, value: [this.value] };
+        return { ...fragtype_utils_1.FT.boolT, value: { node: this.value } };
     }
 }
 exports.Boolean = Boolean;