@malloydata/malloy 0.0.321 → 0.0.323

package/dist/model/expression_compiler.js

@@ -46,43 +46,53 @@ function sqlSumDistinct(dialect, sqlExp, sqlDistintKey) {
     return ret;
 }
 /**
- * Converts an expression to SQL.
- * This function was extracted from QueryField.exprToSQL to break circular dependencies.
+ * Deep copies an expression tree, preserving structure and types.
  */
-function exprToSQL(resultSet, context, exprToTranslate, state = new utils_1.GenerateState()) {
-    var _a;
-    // Wrap non leaf sub expressions in parenthesis
-    const subExpr = function (e) {
-        const sql = exprToSQL(resultSet, context, e, state);
-        if ((0, malloy_types_1.exprHasKids)(e)) {
-            return `(${sql})`;
+function deepCopyExpr(expr) {
+    if ((0, malloy_types_1.exprHasE)(expr)) {
+        return { ...expr, e: deepCopyExpr(expr.e) };
+    }
+    else if ((0, malloy_types_1.exprHasKids)(expr)) {
+        const copiedKids = {};
+        for (const [name, kidExpr] of Object.entries(expr.kids)) {
+            if (kidExpr === null) {
+                copiedKids[name] = null;
+            }
+            else if (Array.isArray(kidExpr)) {
+                copiedKids[name] = kidExpr.map(e => deepCopyExpr(e));
+            }
+            else {
+                copiedKids[name] = deepCopyExpr(kidExpr);
+            }
         }
-        return sql;
-    };
+        return { ...expr, kids: copiedKids };
+    }
+    return { ...expr };
+}
+/**
+ * Compiles an expression tree by mutating it in-place to set all .sql fields.
+ * Assumes the expression tree is already a copy that can be mutated.
+ */
+function compileExpr(resultSet, context, expr, state = new utils_1.GenerateState(), wrap = true) {
     /*
      * Translate the children first, and stash the translation
      * in the nodes themselves, so that if we call into the dialect
      * it will have access to the translated children.
      */
-    let expr = exprToTranslate;
-    if ((0, malloy_types_1.exprHasE)(exprToTranslate)) {
-        expr = { ...exprToTranslate };
-        const eSql = subExpr(expr.e);
-        expr.e = { ...expr.e, sql: eSql };
-    }
-    else if ((0, malloy_types_1.exprHasKids)(exprToTranslate)) {
-        expr = { ...exprToTranslate };
-        const oldKids = exprToTranslate.kids;
-        for (const [name, kidExpr] of Object.entries(oldKids)) {
+    if ((0, malloy_types_1.exprHasE)(expr)) {
+        compileExpr(resultSet, context, expr.e, state);
+    }
+    else if ((0, malloy_types_1.exprHasKids)(expr)) {
+        for (const kidExpr of Object.values(expr.kids)) {
             if (kidExpr === null)
                 continue;
             if (Array.isArray(kidExpr)) {
-                expr.kids[name] = kidExpr.map(e => {
-                    return { ...e, sql: subExpr(e) };
-                });
+                for (const e of kidExpr) {
+                    compileExpr(resultSet, context, e, state);
+                }
             }
             else {
-                expr.kids[name] = { ...oldKids[name], sql: subExpr(kidExpr) };
+                compileExpr(resultSet, context, kidExpr, state);
             }
         }
     }
@@ -92,132 +102,149 @@ function exprToSQL(resultSet, context, exprToTranslate, state = new utils_1.Gene
     const qi = resultSet.getQueryInfo();
     const dialectSQL = context.dialect.exprToSQL(qi, expr);
     if (dialectSQL) {
-        return dialectSQL;
-    }
-    switch (expr.node) {
-        case 'field':
-            return generateFieldFragment(resultSet, context, expr, state);
-        case 'parameter':
-            return generateParameterFragment(resultSet, context, expr, state);
-        case 'filteredExpr':
-            return generateFilterFragment(resultSet, context, expr, state);
-        case 'all':
-        case 'exclude':
-            return generateUngroupedFragment(resultSet, context, expr, state);
-        case 'genericSQLExpr':
-            return Array.from(stringsFromSQLExpression(resultSet, context, expr, state)).join('');
-        case 'aggregate': {
-            let agg = '';
-            if (expr.function === 'sum') {
-                agg = generateSumFragment(resultSet, context, expr, state);
-            }
-            else if (expr.function === 'avg') {
-                agg = generateAvgFragment(resultSet, context, expr, state);
+        expr.sql = wrap && (0, malloy_types_1.exprHasKids)(expr) ? `(${dialectSQL})` : dialectSQL;
+        return expr;
+    }
+    const sql = (() => {
+        var _a;
+        switch (expr.node) {
+            case 'field':
+                return generateFieldFragment(resultSet, context, expr, state);
+            case 'parameter':
+                return generateParameterFragment(resultSet, context, expr, state);
+            case 'filteredExpr':
+                return generateFilterFragment(resultSet, context, expr, state);
+            case 'all':
+            case 'exclude':
+                return generateUngroupedFragment(resultSet, context, expr, state);
+            case 'genericSQLExpr':
+                return Array.from(stringsFromSQLExpression(resultSet, context, expr, state)).join('');
+            case 'aggregate': {
+                let agg = '';
+                if (expr.function === 'sum') {
+                    agg = generateSumFragment(resultSet, context, expr, state);
+                }
+                else if (expr.function === 'avg') {
+                    agg = generateAvgFragment(resultSet, context, expr, state);
+                }
+                else if (expr.function === 'count') {
+                    agg = generateCountFragment(resultSet, context, expr, state);
+                }
+                else if (expr.function === 'min' ||
+                    expr.function === 'max' ||
+                    expr.function === 'distinct') {
+                    agg = generateSymmetricFragment(resultSet, context, expr, state);
+                }
+                else {
+                    throw new Error(`Internal Error: Unknown aggregate function ${expr.function}`);
+                }
+                if (resultSet.root().isComplexQuery) {
+                    let groupSet = resultSet.groupSet;
+                    if (state.totalGroupSet !== -1) {
+                        groupSet = state.totalGroupSet;
+                    }
+                    return (0, utils_1.caseGroup)([groupSet], agg);
+                }
+                return agg;
             }
-            else if (expr.function === 'count') {
-                agg = generateCountFragment(resultSet, context, expr, state);
+            case 'function_parameter':
+                throw new Error('Internal Error: Function parameter fragment remaining during SQL generation');
+            case 'outputField':
+                return generateOutputFieldFragment(resultSet, context, expr, state);
+            case 'function_call':
+                return generateFunctionCallExpression(resultSet, context, expr, state);
+            case 'spread':
+                throw new Error("Internal Error: expandFunctionCall() failed to process node: 'spread'");
+            case 'source-reference':
+                return generateSourceReference(resultSet, context, expr);
+            case '+':
+            case '-':
+            case '*':
+            case '%':
+            case '/':
+            case '>':
+            case '<':
+            case '>=':
+            case '<=':
+            case '=':
+                return `${expr.kids.left.sql}${expr.node}${expr.kids.right.sql}`;
+            // Malloy inequality comparisons always return a boolean
+            case '!=': {
+                const notEqual = `${expr.kids.left.sql}!=${expr.kids.right.sql}`;
+                return `COALESCE(${notEqual},true)`;
             }
-            else if (expr.function === 'min' ||
-                expr.function === 'max' ||
-                expr.function === 'distinct') {
-                agg = generateSymmetricFragment(resultSet, context, expr, state);
+            case 'and':
+            case 'or':
+                return `${expr.kids.left.sql} ${expr.node} ${expr.kids.right.sql}`;
+            case 'coalesce':
+                return `COALESCE(${expr.kids.left.sql},${expr.kids.right.sql})`;
+            case 'in': {
+                const oneOf = expr.kids.oneOf.map(o => o.sql).join(',');
+                return `${expr.kids.e.sql} ${expr.not ? 'NOT IN' : 'IN'} (${oneOf})`;
             }
-            else {
-                throw new Error(`Internal Error: Unknown aggregate function ${expr.function}`);
+            case 'like':
+            case '!like': {
+                const likeIt = expr.node === 'like' ? 'LIKE' : 'NOT LIKE';
+                const compare = expr.kids.right.node === 'stringLiteral'
+                    ? context.dialect.sqlLike(likeIt, (_a = expr.kids.left.sql) !== null && _a !== void 0 ? _a : '', expr.kids.right.literal)
+                    : `${expr.kids.left.sql} ${likeIt} ${expr.kids.right.sql}`;
+                return expr.node === 'like' ? compare : `COALESCE(${compare},true)`;
             }
-            if (resultSet.root().isComplexQuery) {
-                let groupSet = resultSet.groupSet;
-                if (state.totalGroupSet !== -1) {
-                    groupSet = state.totalGroupSet;
+            case '()':
+                return `(${expr.e.sql})`;
+            case 'not':
+                // Malloy not operator always returns a boolean
+                return `COALESCE(NOT ${expr.e.sql},TRUE)`;
+            case 'unary-':
+                return `-${expr.e.sql}`;
+            case 'is-null':
+                return `${expr.e.sql} IS NULL`;
+            case 'is-not-null':
+                return `${expr.e.sql} IS NOT NULL`;
+            case 'true':
+            case 'false':
+                return expr.node;
+            case 'null':
+                return 'NULL';
+            case 'case':
+                return generateCaseSQL(expr);
+            case '':
+                return '';
+            case 'filterCondition':
+                // our child will be translated at the top of this function
+                if (expr.e.sql) {
+                    expr.sql = expr.e.sql;
+                    return expr.sql;
                 }
-                return (0, utils_1.caseGroup)([groupSet], agg);
-            }
-            return agg;
-        }
-        case 'function_parameter':
-            throw new Error('Internal Error: Function parameter fragment remaining during SQL generation');
-        case 'outputField':
-            return generateOutputFieldFragment(resultSet, context, expr, state);
-        case 'function_call':
-            return generateFunctionCallExpression(resultSet, context, expr, state);
-        case 'spread':
-            throw new Error("Internal Error: expandFunctionCall() failed to process node: 'spread'");
-        case 'source-reference':
-            return generateSourceReference(resultSet, context, expr);
-        case '+':
-        case '-':
-        case '*':
-        case '%':
-        case '/':
-        case '>':
-        case '<':
-        case '>=':
-        case '<=':
-        case '=':
-            return `${expr.kids.left.sql}${expr.node}${expr.kids.right.sql}`;
-        // Malloy inequality comparisons always return a boolean
-        case '!=': {
-            const notEqual = `${expr.kids.left.sql}!=${expr.kids.right.sql}`;
-            return `COALESCE(${notEqual},true)`;
-        }
-        case 'and':
-        case 'or':
-            return `${expr.kids.left.sql} ${expr.node} ${expr.kids.right.sql}`;
-        case 'coalesce':
-            return `COALESCE(${expr.kids.left.sql},${expr.kids.right.sql})`;
-        case 'in': {
-            const oneOf = expr.kids.oneOf.map(o => o.sql).join(',');
-            return `${expr.kids.e.sql} ${expr.not ? 'NOT IN' : 'IN'} (${oneOf})`;
-        }
-        case 'like':
-        case '!like': {
-            const likeIt = expr.node === 'like' ? 'LIKE' : 'NOT LIKE';
-            const compare = expr.kids.right.node === 'stringLiteral'
-                ? context.dialect.sqlLike(likeIt, (_a = expr.kids.left.sql) !== null && _a !== void 0 ? _a : '', expr.kids.right.literal)
-                : `${expr.kids.left.sql} ${likeIt} ${expr.kids.right.sql}`;
-            return expr.node === 'like' ? compare : `COALESCE(${compare},true)`;
+                return '';
+            case 'functionDefaultOrderBy':
+            case 'functionOrderBy':
+                return '';
+            // TODO: throw an error here; not simple because we call into this
+            // code currently before the composite source is resolved in some cases
+            case 'compositeField':
+                return '{COMPOSITE_FIELD}';
+            case 'filterMatch':
+                return generateAppliedFilter(context, expr, qi);
+            case 'filterLiteral':
+                return 'INTERNAL ERROR FILTER EXPRESSION VALUE SHOULD NOT BE USED';
+            default:
+                throw new Error(`Internal Error: Unknown expression node '${expr.node}' ${JSON.stringify(expr, undefined, 2)}`);
         }
-        case '()':
-            return `(${expr.e.sql})`;
-        case 'not':
-            // Malloy not operator always returns a boolean
-            return `COALESCE(NOT ${expr.e.sql},TRUE)`;
-        case 'unary-':
-            return `-${expr.e.sql}`;
-        case 'is-null':
-            return `${expr.e.sql} IS NULL`;
-        case 'is-not-null':
-            return `${expr.e.sql} IS NOT NULL`;
-        case 'true':
-        case 'false':
-            return expr.node;
-        case 'null':
-            return 'NULL';
-        case 'case':
-            return generateCaseSQL(expr);
-        case '':
-            return '';
-        case 'filterCondition':
-            // our child will be translated at the top of this function
-            if (expr.e.sql) {
-                expr.sql = expr.e.sql;
-                return expr.sql;
-            }
-            return '';
-        case 'functionDefaultOrderBy':
-        case 'functionOrderBy':
-            return '';
-        // TODO: throw an error here; not simple because we call into this
-        // code currently before the composite source is resolved in some cases
-        case 'compositeField':
-            return '{COMPOSITE_FIELD}';
-        case 'filterMatch':
-            return generateAppliedFilter(context, expr, qi);
-        case 'filterLiteral':
-            return 'INTERNAL ERROR FILTER EXPRESSION VALUE SHOULD NOT BE USED';
-        default:
-            throw new Error(`Internal Error: Unknown expression node '${expr.node}' ${JSON.stringify(expr, undefined, 2)}`);
-    }
+    })();
+    expr.sql = wrap && (0, malloy_types_1.exprHasKids)(expr) ? `(${sql})` : sql;
+    return expr;
+}
+/**
+ * Converts an expression to SQL.
+ * This function was extracted from QueryField.exprToSQL to break circular dependencies.
+ */
+function exprToSQL(resultSet, context, exprToTranslate, state = new utils_1.GenerateState()) {
+    // Make a deep copy that we can mutate during compilation
+    const exprCopy = deepCopyExpr(exprToTranslate);
+    // Compile the copy, setting .sql on all nodes
+    const compiled = compileExpr(resultSet, context, exprCopy, state, false);
+    return compiled.sql;
 }
 function generateAppliedFilter(context, filterMatchExpr, qi) {
     var _a;

package/dist/model/filter_compilers.d.ts

@@ -25,9 +25,7 @@ export declare class TemporalFilterCompiler {
     private literalNode;
     private nowExpr;
     private n;
-    private delta;
     private dayofWeek;
-    private nowDot;
     private thisUnit;
     private lastUnit;
     private nextUnit;

package/dist/model/filter_compilers.js

@@ -340,18 +340,32 @@ class TemporalFilterCompiler {
             }
             case 'for': {
                 const start = this.moment(tc.begin);
-                const end = this.delta(start.begin, '+', tc.n, tc.units);
-                return this.isIn(tc.not, start.begin.sql, end.sql);
+                // start.begin could be any moment (literal, "last monday", etc.)
+                // so we can't optimize through its already-generated SQL
+                const endSql = this.d.sqlTruncAndOffset((0, malloy_types_1.mkTemporal)(start.begin, 'timestamp'), this.qi, undefined, {
+                    op: '+',
+                    magnitude: tc.n,
+                    unit: tc.units,
+                });
+                return this.isIn(tc.not, start.begin.sql, endSql);
             }
             case 'in_last': {
                 // last N units means "N - 1 UNITS AGO FOR N UNITS"
                 const back = Number(tc.n) - 1;
-                const thisUnit = this.nowDot(tc.units);
+                const now = this.nowExpr();
                 const start = back > 0
-                    ? this.delta(thisUnit, '-', back.toString(), tc.units)
-                    : thisUnit;
-                const end = this.delta(thisUnit, '+', '1', tc.units);
-                return this.isIn(tc.not, start.sql, end.sql);
+                    ? this.d.sqlTruncAndOffset(now, this.qi, tc.units, {
+                        op: '-',
+                        magnitude: back.toString(),
+                        unit: tc.units,
+                    })
+                    : this.d.sqlTruncAndOffset(now, this.qi, tc.units);
+                const end = this.d.sqlTruncAndOffset(now, this.qi, tc.units, {
+                    op: '+',
+                    magnitude: '1',
+                    unit: tc.units,
+                });
+                return this.isIn(tc.not, start, end);
             }
             case 'to': {
                 const firstMoment = this.moment(tc.fromMoment);
@@ -359,15 +373,28 @@ class TemporalFilterCompiler {
                 return this.isIn(tc.not, firstMoment.begin.sql, lastMoment.begin.sql);
             }
             case 'last': {
-                const thisUnit = this.nowDot(tc.units);
-                const start = this.delta(thisUnit, '-', tc.n, tc.units);
-                return this.isIn(tc.not, start.sql, thisUnit.sql);
+                const now = this.nowExpr();
+                const start = this.d.sqlTruncAndOffset(now, this.qi, tc.units, {
+                    op: '-',
+                    magnitude: tc.n,
+                    unit: tc.units,
+                });
+                const end = this.d.sqlTruncAndOffset(now, this.qi, tc.units);
+                return this.isIn(tc.not, start, end);
             }
             case 'next': {
-                const thisUnit = this.nowDot(tc.units);
-                const start = this.delta(thisUnit, '+', '1', tc.units);
-                const end = this.delta(thisUnit, '+', (Number(tc.n) + 1).toString(), tc.units);
-                return this.isIn(tc.not, start.sql, end.sql);
+                const now = this.nowExpr();
+                const start = this.d.sqlTruncAndOffset(now, this.qi, tc.units, {
+                    op: '+',
+                    magnitude: '1',
+                    unit: tc.units,
+                });
+                const end = this.d.sqlTruncAndOffset(now, this.qi, tc.units, {
+                    op: '+',
+                    magnitude: (Number(tc.n) + 1).toString(),
+                    unit: tc.units,
+                });
+                return this.isIn(tc.not, start, end);
             }
             case 'null':
                 return tc.not ? `${x} IS NOT NULL` : `${x} IS NULL`;
@@ -476,18 +503,6 @@ class TemporalFilterCompiler {
     n(literal) {
         return { node: 'numberLiteral', literal, sql: literal };
     }
-    delta(from, op, n, units) {
-        const ret = {
-            node: 'delta',
-            op,
-            units,
-            kids: {
-                base: (0, malloy_types_1.mkTemporal)(from, 'timestamp'),
-                delta: this.n(n),
-            },
-        };
-        return { ...ret, sql: this.d.sqlAlterTimeExpr(ret) };
-    }
     dayofWeek(e) {
         const t = {
             node: 'extract',
@@ -496,29 +511,52 @@ class TemporalFilterCompiler {
         };
         return { ...t, sql: this.d.sqlTimeExtractExpr(this.qi, t) };
     }
-    nowDot(units) {
-        const nowTruncExpr = {
-            node: 'trunc',
-            e: this.nowExpr(),
-            units,
-        };
-        return { ...nowTruncExpr, sql: this.d.sqlTruncExpr(this.qi, nowTruncExpr) };
-    }
     thisUnit(units) {
-        const thisUnit = this.nowDot(units);
-        const nextUnit = this.delta(thisUnit, '+', '1', units);
-        return { begin: thisUnit, end: nextUnit.sql };
+        const now = this.nowExpr();
+        const beginSql = this.d.sqlTruncAndOffset(now, this.qi, units);
+        const endSql = this.d.sqlTruncAndOffset(now, this.qi, units, {
+            op: '+',
+            magnitude: '1',
+            unit: units,
+        });
+        const beginNode = { node: 'trunc', e: now, units };
+        return { begin: { ...beginNode, sql: beginSql }, end: endSql };
     }
     lastUnit(units) {
-        const thisUnit = this.nowDot(units);
-        const lastUnit = this.delta(thisUnit, '-', '1', units);
-        return { begin: lastUnit, end: thisUnit.sql };
+        const now = this.nowExpr();
+        const beginSql = this.d.sqlTruncAndOffset(now, this.qi, units, {
+            op: '-',
+            magnitude: '1',
+            unit: units,
+        });
+        const endSql = this.d.sqlTruncAndOffset(now, this.qi, units);
+        const beginNode = {
+            node: 'delta',
+            op: '-',
+            units,
+            kids: { base: now, delta: this.n('1') },
+        };
+        return { begin: { ...beginNode, sql: beginSql }, end: endSql };
     }
     nextUnit(units) {
-        const thisUnit = this.nowDot(units);
-        const nextUnit = this.delta(thisUnit, '+', '1', units);
-        const next2Unit = this.delta(thisUnit, '+', '2', units);
-        return { begin: nextUnit, end: next2Unit.sql };
+        const now = this.nowExpr();
+        const beginSql = this.d.sqlTruncAndOffset(now, this.qi, units, {
+            op: '+',
+            magnitude: '1',
+            unit: units,
+        });
+        const endSql = this.d.sqlTruncAndOffset(now, this.qi, units, {
+            op: '+',
+            magnitude: '2',
+            unit: units,
+        });
+        const beginNode = {
+            node: 'delta',
+            op: '+',
+            units,
+            kids: { base: now, delta: this.n('1') },
+        };
+        return { begin: { ...beginNode, sql: beginSql }, end: endSql };
     }
     mod7(n) {
         return this.d.hasModOperator ? `(${n})%7` : `MOD(${n},7)`;
@@ -533,19 +571,36 @@ class TemporalFilterCompiler {
                 return this.expandLiteral(m);
             case 'ago':
             case 'from_now': {
-                const nowTruncExpr = this.nowDot(m.units);
-                const nowTrunc = (0, malloy_types_1.mkTemporal)(nowTruncExpr, 'timestamp');
-                const beginExpr = this.delta(nowTrunc, m.moment === 'ago' ? '-' : '+', m.n, m.units);
+                const now = this.nowExpr();
+                const op = m.moment === 'ago' ? '-' : '+';
+                const beginSql = this.d.sqlTruncAndOffset(now, this.qi, m.units, {
+                    op,
+                    magnitude: m.n,
+                    unit: m.units,
+                });
+                const beginNode = {
+                    node: 'delta',
+                    op,
+                    units: m.units,
+                    kids: { base: now, delta: this.n(m.n) },
+                };
                 // Now the end is one unit after that .. either n-1 units ago or n+1 units from now
+                let endSql;
                 if (m.moment === 'ago' && m.n === '1') {
-                    return { begin: beginExpr, end: nowTruncExpr.sql };
+                    endSql = this.d.sqlTruncAndOffset(now, this.qi, m.units);
+                }
+                else {
+                    const oneDifferent = Number(m.n) + (m.moment === 'ago' ? -1 : 1);
+                    endSql = this.d.sqlTruncAndOffset(now, this.qi, m.units, {
+                        op,
+                        magnitude: oneDifferent.toString(),
+                        unit: m.units,
+                    });
                 }
-                const oneDifferent = Number(m.n) + (m.moment === 'ago' ? -1 : 1);
-                const endExpr = {
-                    ...beginExpr,
-                    kids: { base: nowTrunc, delta: this.n(oneDifferent.toString()) },
+                return {
+                    begin: { ...beginNode, sql: beginSql },
+                    end: endSql,
                 };
-                return { begin: beginExpr, end: this.d.sqlAlterTimeExpr(endExpr) };
             }
             case 'today':
                 return this.thisUnit('day');
@@ -591,7 +646,7 @@ class TemporalFilterCompiler {
     weekdayMoment(destDay, which) {
         const direction = which || 'last';
         const dow = this.dayofWeek(this.nowExpr());
-        const todayBegin = this.thisUnit('day').begin;
+        const now = this.nowExpr();
         // destDay comes in as 1-7 (Malloy format), convert to 0-6
         const destDayZeroBased = destDay - 1;
         // dow is 1-7, convert to 0-6 for the arithmetic
@@ -612,9 +667,29 @@ class TemporalFilterCompiler {
             // End offset is one day less (closer to today)
             endOffset = `${this.mod7(`${dowZeroBased}-${destDayZeroBased}+6`)}`;
         }
-        const begin = this.delta(todayBegin, direction === 'next' ? '+' : '-', beginOffset, 'day');
-        const end = this.delta(todayBegin, direction === 'next' ? '+' : '-', endOffset, 'day');
-        return { begin, end: end.sql };
+        const op = direction === 'next' ? '+' : '-';
+        const beginSql = this.d.sqlTruncAndOffset(now, this.qi, 'day', {
+            op,
+            magnitude: beginOffset,
+            unit: 'day',
+        });
+        const endSql = this.d.sqlTruncAndOffset(now, this.qi, 'day', {
+            op,
+            magnitude: endOffset,
+            unit: 'day',
+        });
+        // Build an Expr node for begin (truncate now to day, then add offset)
+        const truncatedNow = { node: 'trunc', e: now, units: 'day' };
+        const beginNode = {
+            node: 'delta',
+            op,
+            units: 'day',
+            kids: {
+                base: (0, malloy_types_1.mkTemporal)(truncatedNow, 'timestamp'),
+                delta: this.n(beginOffset),
+            },
+        };
+        return { begin: { ...beginNode, sql: beginSql }, end: endSql };
     }
 }
 exports.TemporalFilterCompiler = TemporalFilterCompiler;