@malloydata/malloy 0.0.177-dev240828173040 → 0.0.177-dev240829030921

package/dist/dialect/dialect.d.ts

@@ -1,4 +1,4 @@
-import { DialectFragment, Expr, ExtractUnit, Sampling, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../model/malloy_types';
+import { Expr, Sampling, FieldAtomicTypeDef, MeasureTimeExpr, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode } from '../model/malloy_types';
 import { DialectFunctionOverloadDef } from './functions';
 type DialectFieldTypes = string | 'struct';
 interface DialectField {
@@ -79,21 +79,31 @@ export declare abstract class Dialect {
     sqlFinalStage(_lastStageName: string, _fields: string[]): string;
     sqlDateToString(sqlDateExp: string): string;
     abstract sqlMaybeQuoteIdentifier(identifier: string): string;
-    abstract sqlNow(): Expr;
-    abstract sqlTrunc(qi: QueryInfo, sqlTime: TimeValue, units: TimestampUnit): Expr;
-    abstract sqlExtract(qi: QueryInfo, sqlTime: TimeValue, units: ExtractUnit): Expr;
-    abstract sqlMeasureTime(from: TimeValue, to: TimeValue, units: TimestampUnit): Expr;
-    abstract sqlAlterTime(op: '+' | '-', expr: TimeValue, n: Expr, timeframe: TimestampUnit): Expr;
-    ignoreInProject(_fieldName: string): boolean;
-    abstract sqlCast(qi: QueryInfo, cast: TypecastFragment): Expr;
-    abstract sqlLiteralTime(qi: QueryInfo, timeString: string, type: TimeFieldType, timezone?: string): string;
-    abstract sqlLiteralString(literal: string): string;
-    abstract sqlLiteralRegexp(literal: string): string;
-    abstract sqlRegexpMatch(expr: Expr, regex: Expr): Expr;
     abstract castToString(expression: string): string;
     abstract concat(...values: string[]): string;
     sqlLiteralNumber(literal: string): string;
-    dialectExpr(qi: QueryInfo, df: DialectFragment): Expr;
+    ignoreInProject(_fieldName: string): boolean;
+    abstract sqlNowExpr(): string;
+    abstract sqlTruncExpr(qi: QueryInfo, toTrunc: TimeTruncExpr): string;
+    abstract sqlTimeExtractExpr(qi: QueryInfo, xFrom: TimeExtractExpr): string;
+    abstract sqlMeasureTimeExpr(e: MeasureTimeExpr): string;
+    abstract sqlAlterTimeExpr(df: TimeDeltaExpr): string;
+    abstract sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    abstract sqlLiteralTime(qi: QueryInfo, df: TimeLiteralNode): string;
+    abstract sqlLiteralString(literal: string): string;
+    abstract sqlLiteralRegexp(literal: string): string;
+    abstract sqlRegexpMatch(df: RegexMatchExpr): string;
+    /**
+     * The dialect has a chance to over-ride how expressions are translated. If
+     * "undefined" is returned then the translation is left to the query translator.
+     *
+     * Any child nodes of the expression will already have been translated, and
+     * the translated value will be in the ".sql" fields for those nodes
+     * @param qi Info from the query containing this expression
+     * @param df The expression being translated
+     * @returns The SQL translation of the expression, or undefined
+     */
+    exprToSQL(qi: QueryInfo, df: Expr): string | undefined;
     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/dialect.js

@@ -23,7 +23,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dialect = exports.qtz = exports.inDays = exports.dayIndex = exports.isDialectFieldStruct = void 0;
-const malloy_types_1 = require("../model/malloy_types");
 function isDialectFieldStruct(d) {
     return d.type === 'struct';
 }
@@ -90,53 +89,60 @@ class Dialect {
     sqlDateToString(sqlDateExp) {
         return this.castToString(`DATE(${sqlDateExp})`);
     }
+    sqlLiteralNumber(literal) {
+        return literal;
+    }
     // BigQuery has some fieldNames that are Pseudo Fields and shouldn't be
     //  included in projections.
     ignoreInProject(_fieldName) {
         return false;
     }
-    sqlLiteralNumber(literal) {
-        return literal;
-    }
-    dialectExpr(qi, df) {
-        switch (df.function) {
+    /**
+     * The dialect has a chance to over-ride how expressions are translated. If
+     * "undefined" is returned then the translation is left to the query translator.
+     *
+     * Any child nodes of the expression will already have been translated, and
+     * the translated value will be in the ".sql" fields for those nodes
+     * @param qi Info from the query containing this expression
+     * @param df The expression being translated
+     * @returns The SQL translation of the expression, or undefined
+     */
+    exprToSQL(qi, df) {
+        switch (df.node) {
             case 'now':
-                return this.sqlNow();
+                return this.sqlNowExpr();
             case 'timeDiff':
-                return this.sqlMeasureTime(df.left, df.right, df.units);
+                return this.sqlMeasureTimeExpr(df);
             case 'delta':
-                return this.sqlAlterTime(df.op, df.base, df.delta, df.units);
+                return this.sqlAlterTimeExpr(df);
             case 'trunc':
-                return this.sqlTrunc(qi, df.expr, df.units);
+                return this.sqlTruncExpr(qi, df);
             case 'extract':
-                return this.sqlExtract(qi, df.expr, df.units);
+                return this.sqlTimeExtractExpr(qi, df);
             case 'cast':
                 return this.sqlCast(qi, df);
             case 'regexpMatch':
-                return this.sqlRegexpMatch(df.expr, df.regexp);
-            case 'div': {
+                return this.sqlRegexpMatch(df);
+            case '/': {
                 if (this.divisionIsInteger) {
-                    return (0, malloy_types_1.mkExpr) `${df.numerator}*1.0/${df.denominator}`;
+                    return `${df.kids.left.sql}*1.0/${df.kids.right.sql}`;
                 }
-                return (0, malloy_types_1.mkExpr) `${df.numerator}/${df.denominator}`;
+                return;
             }
-            case 'mod': {
-                if (this.hasModOperator) {
-                    return (0, malloy_types_1.mkExpr) `${df.numerator}%${df.denominator}`;
+            case '%': {
+                if (!this.hasModOperator) {
+                    return `MOD(${df.kids.left.sql},${df.kids.right.sql})`;
                 }
-                return (0, malloy_types_1.mkExpr) `mod(${df.numerator},${df.denominator})`;
-            }
-            case 'timeLiteral': {
-                return [
-                    this.sqlLiteralTime(qi, df.literal, df.literalType, df.timezone),
-                ];
+                return;
             }
+            case 'timeLiteral':
+                return this.sqlLiteralTime(qi, df);
             case 'stringLiteral':
-                return [this.sqlLiteralString(df.literal)];
+                return this.sqlLiteralString(df.literal);
             case 'numberLiteral':
-                return [this.sqlLiteralNumber(df.literal)];
+                return this.sqlLiteralNumber(df.literal);
             case 'regexpLiteral':
-                return [this.sqlLiteralRegexp(df.literal)];
+                return this.sqlLiteralRegexp(df.literal);
         }
     }
     sqlSumDistinct(_key, _value, _funcName) {

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

@@ -1,7 +1,8 @@
-import { DateUnit, Expr, ExtractUnit, Sampling, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../../model/malloy_types';
+import { Sampling, FieldAtomicTypeDef, TimeDeltaExpr, RegexMatchExpr, MeasureTimeExpr } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
-import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
-export declare class DuckDBDialect extends Dialect {
+import { DialectFieldList } from '../dialect';
+import { PostgresBase } from '../pg_impl';
+export declare class DuckDBDialect extends PostgresBase {
     name: string;
     experimental: boolean;
     defaultNumberType: string;
@@ -42,14 +43,6 @@ export declare class DuckDBDialect extends Dialect {
     sqlSelectAliasAsStruct(alias: string, dialectFieldList: DialectFieldList): string;
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
-    sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
-    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;
     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;
@@ -62,4 +55,7 @@ export declare class DuckDBDialect extends Dialect {
     castToString(expression: string): string;
     concat(...values: string[]): string;
     validateTypeName(sqlType: string): boolean;
+    sqlAlterTimeExpr(df: TimeDeltaExpr): string;
+    sqlRegexpMatch(df: RegexMatchExpr): string;
+    sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
 }

package/dist/dialect/duckdb/duckdb.js

@@ -27,12 +27,9 @@ const malloy_types_1 = require("../../model/malloy_types");
 const utils_1 = require("../../model/utils");
 const functions_1 = require("./functions");
 const dialect_1 = require("../dialect");
+const pg_impl_1 = require("../pg_impl");
 // need to refactor runSQL to take a SQLBlock instead of just a sql string.
 const hackSplitComment = '-- hack: split on this';
-const pgExtractionMap = {
-    'day_of_week': 'dow',
-    'day_of_year': 'doy',
-};
 const duckDBToMalloyTypes = {
     'BIGINT': { type: 'number', numberType: 'integer' },
     'INTEGER': { type: 'number', numberType: 'integer' },
@@ -52,7 +49,7 @@ const duckDBToMalloyTypes = {
     'DECIMAL': { type: 'number', numberType: 'float' },
     'BOOLEAN': { type: 'boolean' },
 };
-class DuckDBDialect extends dialect_1.Dialect {
+class DuckDBDialect extends pg_impl_1.PostgresBase {
     constructor() {
         super(...arguments);
         this.name = 'duckdb';
@@ -212,101 +209,6 @@ class DuckDBDialect extends dialect_1.Dialect {
     sqlCreateTableAsSelect(_tableName, _sql) {
         throw new Error('Not implemented Yet');
     }
-    sqlMeasureTime(from, to, units) {
-        let lVal = from.value;
-        let rVal = to.value;
-        if (!(0, dialect_1.inDays)(units)) {
-            if (from.valueType === 'date') {
-                lVal = (0, malloy_types_1.mkExpr) `(${lVal})::TIMESTAMP`;
-            }
-            if (to.valueType === 'date') {
-                rVal = (0, malloy_types_1.mkExpr) `(${rVal})::TIMESTAMP`;
-            }
-        }
-        return (0, malloy_types_1.mkExpr) `DATE_SUB('${units}',${lVal},${rVal})`;
-    }
-    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) {
-        if (timeframe === 'quarter') {
-            timeframe = 'month';
-            n = (0, malloy_types_1.mkExpr) `${n}*3`;
-        }
-        if (timeframe === 'week') {
-            timeframe = 'day';
-            n = (0, malloy_types_1.mkExpr) `${n}*7`;
-        }
-        const interval = (0, malloy_types_1.mkExpr) `INTERVAL (${n}) ${timeframe}`;
-        return (0, malloy_types_1.mkExpr) `${expr.value} ${op} ${interval}`;
-    }
-    sqlCast(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;
-            const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
-            return (0, malloy_types_1.mkExpr) `${castFunc}(${cast.expr} AS ${dstType})`;
-        }
-        return cast.expr;
-    }
-    sqlRegexpMatch(expr, regexp) {
-        return (0, malloy_types_1.mkExpr) `REGEXP_MATCHES(${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`;
-        }
-        return `TIMESTAMP '${timeString}'`;
-    }
     sqlSumDistinct(key, value, funcName) {
         // return `sum_distinct(list({key:${key}, val: ${value}}))`;
         return `(
@@ -395,6 +297,38 @@ class DuckDBDialect extends dialect_1.Dialect {
         // Brackets:             INT[ ]
         return sqlType.match(/^[A-Za-z\s(),[\]0-9]*$/) !== null;
     }
+    sqlAlterTimeExpr(df) {
+        let timeframe = df.units;
+        let n = df.kids.delta.sql;
+        if (timeframe === 'quarter') {
+            timeframe = 'month';
+            n = `${n}*3`;
+        }
+        else if (timeframe === 'week') {
+            timeframe = 'day';
+            n = `${n}*7`;
+        }
+        const interval = `INTERVAL (${n}) ${timeframe}`;
+        return `${df.kids.base.sql} ${df.op} ${interval}`;
+    }
+    sqlRegexpMatch(df) {
+        return `REGEXP_MATCHES(${df.kids.expr.sql},${df.kids.regex.sql})`;
+    }
+    sqlMeasureTimeExpr(df) {
+        const from = df.kids.left;
+        const to = df.kids.right;
+        let lVal = from.sql || '';
+        let rVal = to.sql || '';
+        if (!(0, dialect_1.inDays)(df.units)) {
+            if (from.dataType === 'date') {
+                lVal = `${lVal}::TIMESTAMP`;
+            }
+            if (to.dataType === 'date') {
+                rVal = `${rVal}::TIMESTAMP`;
+            }
+        }
+        return `DATE_SUB('${df.units}', ${lVal}, ${rVal})`;
+    }
 }
 exports.DuckDBDialect = DuckDBDialect;
 //# sourceMappingURL=duckdb.js.map

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

@@ -38,18 +38,11 @@ function greatestOrLeast(fn) {
     // CASE WHEN arg1 IS NULL OR arg2 is NULL ... OR argN is NULL THEN NULL ELSE GREATEST(arg1, arg2, ..., argN) END
     // But we can't do that with today's function spec.
     // That might look someday like
-    /*
-      sqlFragment(
-        'CASE WHEN ',
-        spread(map(arg('values'), '$ARG IS NULL'), ' OR '),
-        `THEN NULL ELSE ${fn}(`,
-        spread(arg('values')),
-        ') END'
-      ),
-     */
-    [
-        (0, util_1.sqlFragment)('CASE WHEN LEN(LIST_FILTER([', (0, util_1.spread)((0, util_1.arg)('values')), `], x -> x is null)) > 0 THEN NULL ELSE ${fn}(`, (0, util_1.spread)((0, util_1.arg)('values')), ') END'),
-    ]));
+    (0, util_1.sql) `CASE
+  WHEN LEN(LIST_FILTER([${(0, util_1.spread)((0, util_1.arg)('values'))}], x -> x is null)) > 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/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'))})`),

package/dist/dialect/functions/greatest_and_least.js

@@ -35,7 +35,7 @@ const types = [
 // directly, and in BigQuery we add a wrapper to ensure that the null behavior is consistent.
 // It should be that nulls are ignored, rather than propagated.
 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))], [(0, util_1.sqlFragment)(`${fn}(`, (0, util_1.spread)((0, util_1.arg)('values')), ')')]));
+    return types.map(type => (0, util_1.overload)((0, util_1.minScalar)(type), [(0, util_1.params)('values', (0, util_1.anyExprType)(type))], (0, util_1.sql) `${fn}(${(0, util_1.spread)((0, util_1.arg)('values'))})`));
 }
 const fnGreatest = () => greatestOrLeast('GREATEST');
 exports.fnGreatest = fnGreatest;

package/dist/dialect/functions/simple_numeric_functions.js

@@ -26,7 +26,7 @@ exports.fnExp = exports.fnLn = exports.fnSqrt = exports.fnAbs = exports.fnFloor
 const util_1 = require("./util");
 function simple(fn) {
     return [
-        (0, util_1.overload)((0, util_1.minScalar)('number'), [(0, util_1.param)('value', (0, util_1.anyExprType)('number'))], [(0, util_1.sqlFragment)(`${fn}(`, (0, util_1.arg)('value'), ')')]),
+        (0, util_1.overload)((0, util_1.minScalar)('number'), [(0, util_1.param)('value', (0, util_1.anyExprType)('number'))], (0, util_1.sql) `${fn}(${(0, util_1.arg)('value')})`),
     ];
 }
 exports.simple = simple;

package/dist/dialect/functions/sql.js

@@ -26,37 +26,27 @@ exports.fnSqlBoolean = exports.fnSqlTimestamp = exports.fnSqlDate = exports.fnSq
 const util_1 = require("./util");
 function fnSqlNumber() {
     const value = (0, util_1.makeParam)('value', (0, util_1.literal)((0, util_1.maxScalar)('string')));
-    return [
-        (0, util_1.overload)((0, util_1.minScalar)('number'), [value.param], [{ type: 'sql-string', e: [value.arg] }]),
-    ];
+    return [(0, util_1.overload)((0, util_1.minScalar)('number'), [value.param], value.arg)];
 }
 exports.fnSqlNumber = fnSqlNumber;
 function fnSqlString() {
     const value = (0, util_1.makeParam)('value', (0, util_1.literal)((0, util_1.maxScalar)('string')));
-    return [
-        (0, util_1.overload)((0, util_1.minScalar)('string'), [value.param], [{ type: 'sql-string', e: [value.arg] }]),
-    ];
+    return [(0, util_1.overload)((0, util_1.minScalar)('string'), [value.param], value.arg)];
 }
 exports.fnSqlString = fnSqlString;
 function fnSqlDate() {
     const value = (0, util_1.makeParam)('value', (0, util_1.literal)((0, util_1.maxScalar)('string')));
-    return [
-        (0, util_1.overload)((0, util_1.minScalar)('date'), [value.param], [{ type: 'sql-string', e: [value.arg] }]),
-    ];
+    return [(0, util_1.overload)((0, util_1.minScalar)('date'), [value.param], value.arg)];
 }
 exports.fnSqlDate = fnSqlDate;
 function fnSqlTimestamp() {
     const value = (0, util_1.makeParam)('value', (0, util_1.literal)((0, util_1.maxScalar)('string')));
-    return [
-        (0, util_1.overload)((0, util_1.minScalar)('timestamp'), [value.param], [{ type: 'sql-string', e: [value.arg] }]),
-    ];
+    return [(0, util_1.overload)((0, util_1.minScalar)('timestamp'), [value.param], value.arg)];
 }
 exports.fnSqlTimestamp = fnSqlTimestamp;
 function fnSqlBoolean() {
     const value = (0, util_1.makeParam)('value', (0, util_1.literal)((0, util_1.maxScalar)('string')));
-    return [
-        (0, util_1.overload)((0, util_1.minScalar)('boolean'), [value.param], [{ type: 'sql-string', e: [value.arg] }]),
-    ];
+    return [(0, util_1.overload)((0, util_1.minScalar)('boolean'), [value.param], value.arg)];
 }
 exports.fnSqlBoolean = fnSqlBoolean;
 //# sourceMappingURL=sql.js.map

package/dist/dialect/functions/string_agg.js

@@ -27,7 +27,7 @@ const util_1 = require("./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, 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})`, { supportsOrderBy: true, defaultOrderByArgIndex: 0 }),
@@ -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/functions/trim_functions.js

@@ -26,11 +26,11 @@ exports.fnRtrim = exports.fnLtrim = exports.fnTrim = void 0;
 const util_1 = require("./util");
 function trimFn(fn) {
     return [
-        (0, util_1.overload)((0, util_1.minScalar)('string'), [(0, util_1.param)('value', (0, util_1.anyExprType)('string'))], [(0, util_1.sqlFragment)(`${fn}(`, (0, util_1.arg)('value'), ')')]),
+        (0, util_1.overload)((0, util_1.minScalar)('string'), [(0, util_1.param)('value', (0, util_1.anyExprType)('string'))], (0, util_1.sql) `${fn}(${(0, util_1.arg)('value')})`),
         (0, util_1.overload)((0, util_1.minScalar)('string'), [
             (0, util_1.param)('value', (0, util_1.anyExprType)('string')),
             (0, util_1.param)('trim_characters', (0, util_1.anyExprType)('string')),
-        ], [(0, util_1.sqlFragment)(`${fn}(`, (0, util_1.arg)('value'), ',', (0, util_1.arg)('trim_characters'), ')')]),
+        ], (0, util_1.sql) `${fn}(${(0, util_1.arg)('value')},${(0, util_1.arg)('trim_characters')})`),
     ];
 }
 const fnTrim = () => trimFn('TRIM');

package/dist/dialect/functions/util.d.ts

@@ -1,4 +1,5 @@
-import { FunctionParameterDef, Fragment, FieldValueType, TypeDesc, Expr, FunctionParamTypeDesc } from '../../model/malloy_types';
+import { FunctionParameterDef, FieldValueType, TypeDesc, Expr, FunctionParamTypeDesc } from '../../model/malloy_types';
+import { SQLExprElement } from '../../model/utils';
 export interface DialectFunctionOverloadDef {
     returnType: TypeDesc;
     params: FunctionParameterDef[];
@@ -13,13 +14,9 @@ export interface DialectFunctionOverloadDef {
         following: number | string;
     } | undefined;
 }
-export declare function arg(name: string): Fragment;
-export declare function spread(f: Fragment, prefix?: string | undefined, suffix?: string | undefined): Fragment;
-/**
- * Prefer `sql` when possible.
- */
-export declare function sqlFragment(...e: Expr): Fragment;
-export declare function sql(strings: TemplateStringsArray, ...expr: (Fragment | string)[]): Expr;
+export declare function arg(name: string): Expr;
+export declare function spread(e: Expr, prefix?: string | undefined, suffix?: string | undefined): Expr;
+export declare function sql(strings: TemplateStringsArray, ...subExprs: SQLExprElement[]): Expr;
 export declare function constant(type: TypeDesc): TypeDesc;
 export declare function output(type: TypeDesc): TypeDesc;
 export declare function literal(type: TypeDesc): TypeDesc;
@@ -30,7 +27,7 @@ export declare function params(name: string, ...allowedTypes: FunctionParamTypeD
 export declare function param(name: string, ...allowedTypes: FunctionParamTypeDesc[]): FunctionParameterDef;
 export declare function makeParam(name: string, ...allowedTypes: FunctionParamTypeDesc[]): {
     param: FunctionParameterDef;
-    arg: Fragment;
+    arg: Expr;
 };
 export declare function maxScalar(dataType: FieldValueType): TypeDesc;
 export declare function maxAggregate(dataType: FieldValueType): TypeDesc;

package/dist/dialect/functions/util.js

@@ -22,52 +22,43 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.overload = exports.minAnalytic = exports.minAggregate = exports.minScalar = exports.maxAnalytic = exports.maxUngroupedAggregate = exports.anyExprType = exports.maxAggregate = exports.maxScalar = exports.makeParam = exports.param = exports.params = exports.literal = exports.output = exports.constant = exports.sql = exports.sqlFragment = exports.spread = exports.arg = void 0;
+exports.overload = exports.minAnalytic = exports.minAggregate = exports.minScalar = exports.maxAnalytic = exports.maxUngroupedAggregate = exports.anyExprType = exports.maxAggregate = exports.maxScalar = exports.makeParam = exports.param = exports.params = exports.literal = exports.output = exports.constant = exports.sql = exports.spread = exports.arg = void 0;
 function arg(name) {
-    return {
-        type: 'function_parameter',
-        name,
-    };
+    return { node: 'function_parameter', name };
 }
 exports.arg = arg;
-function spread(f, prefix = undefined, suffix = undefined) {
-    return {
-        type: 'spread',
-        e: [f],
-        prefix,
-        suffix,
-    };
+function spread(e, prefix = undefined, suffix = undefined) {
+    return { node: 'spread', e, prefix, suffix };
 }
 exports.spread = spread;
-/**
- * Prefer `sql` when possible.
- */
-function sqlFragment(...e) {
-    return {
-        type: 'sql_expression',
-        e,
-    };
-}
-exports.sqlFragment = sqlFragment;
-function sql(strings, ...expr) {
-    return [
-        {
-            type: 'sql_expression',
-            e: interpolate([...strings], expr),
-        },
-    ];
-}
-exports.sql = sql;
-function interpolate(outer, inner) {
-    const result = [];
-    for (let i = 0; i < outer.length; i++) {
-        result.push(outer[i]);
-        if (i < inner.length) {
-            result.push(inner[i]);
+function sql(strings, ...subExprs) {
+    const ret = {
+        node: 'genericSQLExpr',
+        kids: { args: [] },
+        src: [],
+    };
+    const safeExprs = [...subExprs];
+    let srcToPush = '';
+    for (const str of strings) {
+        srcToPush += str;
+        const arg = safeExprs.shift();
+        if (arg !== undefined) {
+            if (typeof arg === 'string') {
+                srcToPush += arg;
+            }
+            else {
+                ret.src.push(srcToPush);
+                ret.kids.args.push(arg);
+                srcToPush = '';
+            }
         }
     }
-    return result;
+    if (srcToPush.length > 0) {
+        ret.src.push(srcToPush);
+    }
+    return ret;
 }
+exports.sql = sql;
 function constant(type) {
     return {
         ...type,

package/dist/dialect/index.d.ts

@@ -1,5 +1,5 @@
 export type { DialectFunctionOverloadDef } from './functions/util';
-export { arg, anyExprType, makeParam, overload, minScalar, minAggregate, maxScalar, spread, sqlFragment, param, params, literal, sql, } from './functions/util';
+export { arg, anyExprType, makeParam, overload, minScalar, minAggregate, maxScalar, spread, param, params, literal, sql, } from './functions/util';
 export { Dialect, qtz } from './dialect';
 export type { DialectFieldList, QueryInfo } from './dialect';
 export { StandardSQLDialect } from './standardsql';

package/dist/dialect/index.js

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FUNCTIONS = exports.getDialectFunction = exports.registerDialect = exports.getDialect = exports.TrinoDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.qtz = exports.Dialect = exports.sql = exports.literal = exports.params = exports.param = exports.sqlFragment = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
+exports.FUNCTIONS = exports.getDialectFunction = exports.registerDialect = exports.getDialect = exports.TrinoDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.qtz = exports.Dialect = exports.sql = exports.literal = exports.params = exports.param = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
 var util_1 = require("./functions/util");
 Object.defineProperty(exports, "arg", { enumerable: true, get: function () { return util_1.arg; } });
 Object.defineProperty(exports, "anyExprType", { enumerable: true, get: function () { return util_1.anyExprType; } });
@@ -32,7 +32,6 @@ Object.defineProperty(exports, "minScalar", { enumerable: true, get: function ()
 Object.defineProperty(exports, "minAggregate", { enumerable: true, get: function () { return util_1.minAggregate; } });
 Object.defineProperty(exports, "maxScalar", { enumerable: true, get: function () { return util_1.maxScalar; } });
 Object.defineProperty(exports, "spread", { enumerable: true, get: function () { return util_1.spread; } });
-Object.defineProperty(exports, "sqlFragment", { enumerable: true, get: function () { return util_1.sqlFragment; } });
 Object.defineProperty(exports, "param", { enumerable: true, get: function () { return util_1.param; } });
 Object.defineProperty(exports, "params", { enumerable: true, get: function () { return util_1.params; } });
 Object.defineProperty(exports, "literal", { enumerable: true, get: function () { return util_1.literal; } });

package/dist/dialect/pg_impl.d.ts

@@ -0,0 +1,15 @@
+import { RegexMatchExpr, TimeExtractExpr, TimeLiteralNode, TimeTruncExpr, TypecastExpr } from '../model/malloy_types';
+import { Dialect, QueryInfo } from './dialect';
+export declare const timeExtractMap: Record<string, string>;
+/**
+ * Many SQL implementations started with the PostGres source, and therefore can use the
+ * same implementations for the much of the SQL code generation
+ */
+export declare abstract class PostgresBase extends Dialect {
+    sqlTruncExpr(qi: QueryInfo, df: TimeTruncExpr): string;
+    sqlNowExpr(): string;
+    sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
+    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlRegexpMatch(df: RegexMatchExpr): string;
+    sqlLiteralTime(qi: QueryInfo, lt: TimeLiteralNode): string;
+}