@malloydata/malloy 0.0.263-dev250414165131 → 0.0.263-dev250414204152

package/dist/model/malloy_query.js

@@ -890,20 +890,55 @@ class QueryField extends QueryNode {
             case 'compositeField':
                 return '{COMPOSITE_FIELD}';
             case 'filterMatch':
-                if (expr.dataType === 'string' ||
-                    expr.dataType === 'number' ||
-                    expr.dataType === 'date' ||
-                    expr.dataType === 'timestamp' ||
-                    expr.dataType === 'boolean') {
-                    if (expr.filter === null || (0, malloy_filter_1.isFilterExpression)(expr.filter)) {
-                        return filter_compilers_1.FilterCompilers.compile(expr.dataType, expr.filter, expr.e.sql || '', this.parent.dialect);
-                    }
-                }
-                throw new Error(`Internal Error: Filter Compiler Undefined Type '${expr.dataType}'`);
+                return this.generateAppliedFilter(context, expr);
+            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)}`);
         }
     }
+    generateAppliedFilter(context, filterMatchExpr) {
+        var _a;
+        let filterExpr = filterMatchExpr.kids.filterExpr;
+        while (filterExpr.node === '()') {
+            filterExpr = filterExpr.e;
+        }
+        if (filterExpr.node === 'parameter') {
+            const name = filterExpr.path[0];
+            (_a = context.eventStream) === null || _a === void 0 ? void 0 : _a.emit('source-argument-compiled', { name });
+            const argument = context.arguments()[name];
+            if (argument.value) {
+                filterExpr = argument.value;
+            }
+            else {
+                throw new Error(`Parameter ${name} was expected to be a filter expression`);
+            }
+        }
+        if (filterExpr.node !== 'filterLiteral') {
+            throw new Error('Can only use filter expression literals or parameters as filter expressions');
+        }
+        const filterSrc = filterExpr.filterSrc;
+        let fParse;
+        switch (filterMatchExpr.dataType) {
+            case 'string':
+                fParse = malloy_filter_1.StringFilterExpression.parse(filterSrc);
+                break;
+            case 'number':
+                fParse = malloy_filter_1.NumberFilterExpression.parse(filterSrc);
+                break;
+            case 'boolean':
+                fParse = malloy_filter_1.BooleanFilterExpression.parse(filterSrc);
+                break;
+            case 'date':
+            case 'timestamp':
+                fParse = malloy_filter_1.TemporalFilterExpression.parse(filterSrc);
+                break;
+        }
+        if (fParse.log.length > 0) {
+            throw new Error(`Filter expression parse error: ${fParse.log[0]}`);
+        }
+        return filter_compilers_1.FilterCompilers.compile(filterMatchExpr.dataType, fParse.parsed, filterMatchExpr.kids.expr.sql || '', context.dialect);
+    }
     isNestedInParent(parentDef) {
         switch (parentDef.type) {
             case 'record':
@@ -3725,28 +3760,34 @@ class QueryModel {
         };
     }
     addDefaultRowLimit(query, defaultRowLimit) {
+        const nope = { query, addedDefaultRowLimit: undefined };
         if (defaultRowLimit === undefined)
-            return query;
+            return nope;
         const lastSegment = query.pipeline[query.pipeline.length - 1];
         if (lastSegment.type === 'raw')
-            return query;
+            return nope;
         if (lastSegment.limit !== undefined)
-            return query;
+            return nope;
         return {
-            ...query,
-            pipeline: [
-                ...query.pipeline.slice(0, -1),
-                {
-                    ...lastSegment,
-                    limit: defaultRowLimit,
-                },
-            ],
+            query: {
+                ...query,
+                pipeline: [
+                    ...query.pipeline.slice(0, -1),
+                    {
+                        ...lastSegment,
+                        limit: defaultRowLimit,
+                    },
+                ],
+            },
+            addedDefaultRowLimit: defaultRowLimit,
         };
     }
     compileQuery(query, prepareResultOptions, finalize = true) {
         var _a, _b;
         let newModel;
-        query = this.addDefaultRowLimit(query, prepareResultOptions === null || prepareResultOptions === void 0 ? void 0 : prepareResultOptions.defaultRowLimit);
+        const addDefaultRowLimit = this.addDefaultRowLimit(query, prepareResultOptions === null || prepareResultOptions === void 0 ? void 0 : prepareResultOptions.defaultRowLimit);
+        query = addDefaultRowLimit.query;
+        const addedDefaultRowLimit = addDefaultRowLimit.addedDefaultRowLimit;
         const m = newModel || this;
         const ret = m.loadQuery(query, undefined, prepareResultOptions, finalize, false);
         const structRef = (_a = query.compositeResolvedSourceDef) !== null && _a !== void 0 ? _a : query.structRef;
@@ -3774,6 +3815,7 @@ class QueryModel {
             connectionName: ret.connectionName,
             annotation: query.annotation,
             queryTimezone: ret.structs[0].queryTimezone,
+            defaultRowLimitAdded: addedDefaultRowLimit,
         };
     }
     async searchIndex(connection, explore, searchValue, limit = 1000, searchField = undefined) {

package/dist/model/malloy_types.d.ts

@@ -25,7 +25,7 @@ export type AnyExpr = ExprE | ExprOptionalE | ExprWithKids | ExprLeaf;
 export declare function exprHasKids(e: AnyExpr): e is ExprWithKids;
 export declare function exprHasE(e: AnyExpr): e is ExprE;
 export declare function exprIsLeaf(e: AnyExpr): boolean;
-export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | NowNode | MeasureTimeExpr | TimeExtractExpr | TimeDeltaExpr | TimeTruncExpr | TimeLiteralNode | TypecastExpr | RegexMatchExpr | RegexLiteralNode | FilterMatchExpr | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | RecordLiteralNode | ArrayLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | CaseExpr | InCompareExpr | CompositeFieldExpr | ErrorNode;
+export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | NowNode | MeasureTimeExpr | TimeExtractExpr | TimeDeltaExpr | TimeTruncExpr | TimeLiteralNode | TypecastExpr | RegexMatchExpr | RegexLiteralNode | FilterMatchExpr | FilterLiteralExpr | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | RecordLiteralNode | ArrayLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | CaseExpr | InCompareExpr | CompositeFieldExpr | ErrorNode;
 export type BinaryOperator = '+' | '-' | '*' | '%' | '/' | 'and' | 'or' | '=' | '!=' | '>' | '<' | '>=' | '<=' | 'coalesce' | 'like' | '!like';
 export interface BinaryExpr extends ExprWithKids {
     node: BinaryOperator;
@@ -175,13 +175,18 @@ export interface RegexMatchExpr extends ExprWithKids {
 }
 export type FilterExprType = 'string' | 'number' | 'boolean' | 'date' | 'timestamp';
 export declare function isFilterExprType(s: string): s is FilterExprType;
-export interface FilterMatchExpr extends ExprE {
+export interface FilterMatchExpr extends ExprWithKids {
     node: 'filterMatch';
     dataType: FilterExprType;
     notMatch?: true;
-    filter: {
-        operator: string;
-    } | null;
+    kids: {
+        filterExpr: Expr;
+        expr: Expr;
+    };
+}
+export interface FilterLiteralExpr extends ExprLeaf {
+    node: 'filterLiteral';
+    filterSrc: string;
 }
 export interface TimeLiteralNode extends ExprLeaf {
     node: 'timeLiteral';
@@ -262,7 +267,14 @@ interface ParameterInfo {
     name: string;
     value: ConstantExpr | null;
 }
-export type Parameter = AtomicTypeDef & ParameterInfo;
+export interface FilterExpressionDef {
+    type: 'filter expression';
+    filterType?: FilterExprType;
+}
+export type ParameterType = CastType | 'filter expression';
+export declare function isParameterType(t: string): t is ParameterType;
+export type ParameterTypeDef = AtomicTypeDef | FilterExpressionDef;
+export type Parameter = ParameterTypeDef & ParameterInfo;
 export type Argument = Parameter;
 export declare function paramHasValue(p: Parameter): boolean;
 export interface DocumentRange {
@@ -827,6 +839,7 @@ export interface CompiledQuery extends DrillSource {
     annotation?: Annotation;
     dependenciesToMaterialize?: Record<string, QueryToMaterialize>;
     materialization?: QueryToMaterialize;
+    defaultRowLimitAdded?: number;
 }
 /** Result type for running a Malloy query. */
 export interface QueryResult extends CompiledQuery {

package/dist/model/malloy_types.js

@@ -23,8 +23,8 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sourceBase = exports.isSegmentSQL = exports.isIndexSegment = exports.isRawSegment = exports.isSamplingEnable = exports.isSamplingPercent = exports.isSamplingRows = exports.isQuerySegment = exports.isProjectSegment = exports.isPartialSegment = exports.isReduceSegment = exports.structHasErrors = exports.segmentHasErrors = exports.refIsStructDef = exports.ValueType = exports.isExtractUnit = exports.isTimestampUnit = exports.isDateUnit = exports.isJoinedSource = exports.isJoined = exports.isJoinable = exports.isMatrixOperation = exports.isBasicArray = exports.isRepeatedRecord = exports.isRepeatedRecordFunctionParam = exports.mkArrayDef = exports.mkFieldDef = exports.fieldIsIntrinsic = exports.isCastType = exports.canOrderBy = exports.isAtomicFieldType = exports.isTemporalType = exports.hasExpression = exports.maxOfExpressionTypes = exports.maxExpressionType = exports.isExpressionTypeLEQ = exports.expressionIsAnalytic = exports.expressionIsCalculation = exports.expressionInvolvesAggregate = exports.expressionIsUngroupedAggregate = exports.expressionIsAggregate = exports.expressionIsScalar = exports.paramHasValue = exports.isFilterExprType = exports.isRawCast = exports.mkTemporal = exports.isAsymmetricExpr = exports.exprIsLeaf = exports.exprHasE = exports.exprHasKids = void 0;
-exports.TD = exports.isValueDate = exports.isValueTimestamp = exports.isValueBoolean = exports.isValueNumber = exports.isValueString = exports.isAtomic = exports.isTurtle = exports.getIdentifier = exports.isBasicAtomic = exports.mergeEvalSpaces = exports.isLiteral = exports.isBaseTable = exports.isSourceDef = void 0;
+exports.isSegmentSQL = exports.isIndexSegment = exports.isRawSegment = exports.isSamplingEnable = exports.isSamplingPercent = exports.isSamplingRows = exports.isQuerySegment = exports.isProjectSegment = exports.isPartialSegment = exports.isReduceSegment = exports.structHasErrors = exports.segmentHasErrors = exports.refIsStructDef = exports.ValueType = exports.isExtractUnit = exports.isTimestampUnit = exports.isDateUnit = exports.isJoinedSource = exports.isJoined = exports.isJoinable = exports.isMatrixOperation = exports.isBasicArray = exports.isRepeatedRecord = exports.isRepeatedRecordFunctionParam = exports.mkArrayDef = exports.mkFieldDef = exports.fieldIsIntrinsic = exports.isCastType = exports.canOrderBy = exports.isAtomicFieldType = exports.isTemporalType = exports.hasExpression = exports.maxOfExpressionTypes = exports.maxExpressionType = exports.isExpressionTypeLEQ = exports.expressionIsAnalytic = exports.expressionIsCalculation = exports.expressionInvolvesAggregate = exports.expressionIsUngroupedAggregate = exports.expressionIsAggregate = exports.expressionIsScalar = exports.paramHasValue = exports.isParameterType = exports.isFilterExprType = exports.isRawCast = exports.mkTemporal = exports.isAsymmetricExpr = exports.exprIsLeaf = exports.exprHasE = exports.exprHasKids = void 0;
+exports.TD = exports.isValueDate = exports.isValueTimestamp = exports.isValueBoolean = exports.isValueNumber = exports.isValueString = exports.isAtomic = exports.isTurtle = exports.getIdentifier = exports.isBasicAtomic = exports.mergeEvalSpaces = exports.isLiteral = exports.isBaseTable = exports.isSourceDef = exports.sourceBase = void 0;
 function exprHasKids(e) {
     return 'kids' in e;
 }
@@ -75,6 +75,10 @@ function isFilterExprType(s) {
     return ['string', 'number', 'boolean', 'date', 'timestamp'].includes(s);
 }
 exports.isFilterExprType = isFilterExprType;
+function isParameterType(t) {
+    return isCastType(t) || t === 'filter expression';
+}
+exports.isParameterType = isParameterType;
 function paramHasValue(p) {
     return p.value !== null;
 }

package/dist/to_stable.js

@@ -21,11 +21,20 @@ function modelDefToModelInfo(modelDef) {
             continue;
         if ((0, model_1.isSourceDef)(entry)) {
             const parameters = entry.parameters && Object.entries(entry.parameters).length > 0
-                ? Object.entries(entry.parameters).map(([name, parameter]) => ({
-                    name,
-                    type: typeDefToType(parameter),
-                    default_value: convertParameterDefaultValue(parameter.value),
-                }))
+                ? Object.entries(entry.parameters).map(([name, parameter]) => {
+                    if ((0, model_1.isAtomic)(parameter)) {
+                        return {
+                            name,
+                            type: typeDefToType(parameter),
+                            default_value: convertParameterDefaultValue(parameter.value),
+                        };
+                    }
+                    return {
+                        name,
+                        type: { kind: 'filter_expression_type' },
+                        default_value: convertParameterDefaultValue(parameter.value),
+                    };
+                })
                 : undefined;
             const sourceInfo = {
                 kind: 'source',
@@ -89,6 +98,11 @@ function convertParameterDefaultValue(value) {
             return { kind: 'number_literal', number_value: parseFloat(value.literal) };
         case 'stringLiteral':
             return { kind: 'string_literal', string_value: value.literal };
+        case 'filterLiteral':
+            return {
+                kind: 'filter_expression_literal',
+                filter_expression_value: value.filterSrc,
+            };
         case 'timeLiteral':
             return {
                 kind: 'timestamp_literal',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.263-dev250414165131",
+  "version": "0.0.263-dev250414204152",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -41,9 +41,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "^0.0.263-dev250414165131",
-    "@malloydata/malloy-interfaces": "^0.0.263-dev250414165131",
-    "@malloydata/malloy-tag": "^0.0.263-dev250414165131",
+    "@malloydata/malloy-filter": "^0.0.263-dev250414204152",
+    "@malloydata/malloy-interfaces": "^0.0.263-dev250414204152",
+    "@malloydata/malloy-tag": "^0.0.263-dev250414204152",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",

package/dist/model/filter_temporal_compiler.d.ts

@@ -1,29 +0,0 @@
-import type { TemporalFilter } from '@malloydata/malloy-filter';
-import type { Dialect } from '../dialect';
-/**
- * I felt like there was enough "helpful functions needed to make everything
- * work, all of which need to know the dialect", to justify making a class
- * for this. Maybe this should just be a set of functions which take
- * a dialect as an argument?
- */
-export declare class TemporalFilterCompiler {
-    readonly expr: string;
-    readonly timetype: 'timestamp' | 'date';
-    readonly d: Dialect;
-    constructor(expr: string, dialect: Dialect, timetype?: 'timestamp' | 'date');
-    time(timeSQL: string): string;
-    compile(tc: TemporalFilter): string;
-    private expandLiteral;
-    private literalNode;
-    private nowExpr;
-    private n;
-    private delta;
-    private dayofWeek;
-    private nowDot;
-    private thisUnit;
-    private lastUnit;
-    private nextUnit;
-    mod7(n: string): string;
-    private moment;
-    private isIn;
-}

package/dist/model/filter_temporal_compiler.js

@@ -1,343 +0,0 @@
-"use strict";
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemporalFilterCompiler = void 0;
-const malloy_types_1 = require("./malloy_types");
-const luxon_1 = require("luxon");
-const fYear = 'yyyy';
-const fMonth = `${fYear}-LL`;
-const fDay = `${fMonth}-dd`;
-const fHour = `${fDay} HH`;
-const fMinute = `${fHour}:mm`;
-const fTimestamp = `${fMinute}:ss`;
-/**
- * I felt like there was enough "helpful functions needed to make everything
- * work, all of which need to know the dialect", to justify making a class
- * for this. Maybe this should just be a set of functions which take
- * a dialect as an argument?
- */
-class TemporalFilterCompiler {
-    constructor(expr, dialect, timetype = 'timestamp') {
-        this.expr = expr;
-        this.timetype = timetype;
-        this.d = dialect;
-    }
-    time(timeSQL) {
-        if (this.timetype === 'timestamp') {
-            return timeSQL;
-        }
-        return this.d.sqlCast({}, {
-            node: 'cast',
-            e: {
-                node: 'genericSQLExpr',
-                src: ['', timeSQL],
-                kids: { args: [] },
-                sql: timeSQL,
-            },
-            srcType: { type: 'timestamp' },
-            dstType: { type: 'date' },
-            safe: false,
-        });
-    }
-    compile(tc) {
-        const x = this.expr;
-        switch (tc.operator) {
-            case 'after':
-                return `${x} ${tc.not ? '<' : '>='} ${this.time(this.moment(tc.after).end)}`;
-            case 'before':
-                return `${x} ${tc.not ? '>=' : '<'} ${this.time(this.moment(tc.before).begin.sql)}`;
-            case 'in': {
-                const m = this.moment(tc.in);
-                if (m.begin.sql === m.end) {
-                    return tc.not
-                        ? `${x} != ${this.time(m.end)} OR ${x} IS NULL`
-                        : `${x} = ${this.time(m.end)}`;
-                }
-                return this.isIn(tc.not, m.begin.sql, m.end);
-            }
-            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);
-            }
-            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 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);
-            }
-            case 'to': {
-                const firstMoment = this.moment(tc.fromMoment);
-                const lastMoment = this.moment(tc.toMoment);
-                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);
-            }
-            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);
-            }
-            case 'null':
-                return tc.not ? `${x} IS NOT NULL` : `${x} IS NULL`;
-            case '()': {
-                const wrapped = '(' + this.compile(tc.expr) + ')';
-                return tc.not ? `NOT ${wrapped}` : wrapped;
-            }
-            case 'and':
-            case 'or':
-                return tc.members
-                    .map(m => this.compile(m))
-                    .join(` ${tc.operator.toUpperCase()} `);
-        }
-    }
-    expandLiteral(tl) {
-        let literal = tl.literal;
-        switch (tl.units) {
-            case 'year': {
-                const y = luxon_1.DateTime.fromFormat(literal, fYear);
-                const begin = this.literalNode(y.toFormat(fTimestamp));
-                const next = y.plus({ year: 1 });
-                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
-            }
-            case 'month': {
-                const yyyymm = luxon_1.DateTime.fromFormat(literal, fMonth);
-                const begin = this.literalNode(yyyymm.toFormat(fTimestamp));
-                const next = yyyymm.plus({ month: 1 });
-                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
-            }
-            case 'day': {
-                const yyyymmdd = luxon_1.DateTime.fromFormat(literal, fDay);
-                const begin = this.literalNode(yyyymmdd.toFormat(fTimestamp));
-                const next = yyyymmdd.plus({ day: 1 });
-                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
-            }
-            case 'hour': {
-                const ymdh = luxon_1.DateTime.fromFormat(literal, fHour);
-                const begin = this.literalNode(ymdh.toFormat(fTimestamp));
-                const next = ymdh.plus({ hour: 1 });
-                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
-            }
-            case 'minute': {
-                const ymdhm = luxon_1.DateTime.fromFormat(literal, fMinute);
-                const begin = this.literalNode(ymdhm.toFormat(fTimestamp));
-                const next = ymdhm.plus({ minute: 1 });
-                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
-            }
-            case 'week': {
-                const a = luxon_1.DateTime.fromFormat(literal.slice(0, 10), fDay);
-                // Luxon uses monday weeks, so look for the Monday week which contains
-                // the day after, which for all days except Sunday is the same as
-                // the sunday week, and on Sunday it is this monday week instead of
-                // last monday week.
-                const mondayWeek = a.plus({ day: 1 }).startOf('week');
-                // Now back that up by one day and we have the Sunday week
-                const ymd_wk = mondayWeek.minus({ day: 1 });
-                const begin = this.literalNode(ymd_wk.toFormat(fTimestamp));
-                const next = ymd_wk.plus({ days: 7 });
-                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
-            }
-            case 'quarter': {
-                const yyyy = literal.slice(0, 4);
-                const q = literal.slice(6);
-                if (q === '1') {
-                    literal = `${yyyy}-01-01 00:00:00`;
-                }
-                else if (q === '2') {
-                    literal = `${yyyy}-03-01 00:00:00`;
-                }
-                else if (q === '3') {
-                    literal = `${yyyy}-06-01 00:00:00`;
-                }
-                else {
-                    literal = `${yyyy}-09-01 00:00:00`;
-                }
-                const begin = this.literalNode(literal);
-                const ymd_q = luxon_1.DateTime.fromFormat(literal, fTimestamp);
-                const next = ymd_q.plus({ months: 3 });
-                return { begin, end: this.literalNode(next.toFormat(fTimestamp)).sql };
-            }
-            case undefined:
-            case 'second': {
-                const begin = this.literalNode(literal);
-                return { begin, end: begin.sql };
-            }
-        }
-    }
-    literalNode(literal) {
-        const literalNode = {
-            node: 'timeLiteral',
-            typeDef: { type: 'timestamp' },
-            literal,
-        };
-        return { ...literalNode, sql: this.d.sqlLiteralTime({}, literalNode) };
-    }
-    nowExpr() {
-        return {
-            node: 'now',
-            typeDef: { type: 'timestamp' },
-            sql: this.d.sqlNowExpr(),
-        };
-    }
-    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',
-            e: (0, malloy_types_1.mkTemporal)(e, 'timestamp'),
-            units: 'day_of_week',
-        };
-        return { ...t, sql: this.d.sqlTimeExtractExpr({}, t) };
-    }
-    nowDot(units) {
-        const nowTruncExpr = {
-            node: 'trunc',
-            e: this.nowExpr(),
-            units,
-        };
-        return { ...nowTruncExpr, sql: this.d.sqlTruncExpr({}, nowTruncExpr) };
-    }
-    thisUnit(units) {
-        const thisUnit = this.nowDot(units);
-        const nextUnit = this.delta(thisUnit, '+', '1', units);
-        return { begin: thisUnit, end: nextUnit.sql };
-    }
-    lastUnit(units) {
-        const thisUnit = this.nowDot(units);
-        const lastUnit = this.delta(thisUnit, '-', '1', units);
-        return { begin: lastUnit, end: thisUnit.sql };
-    }
-    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 };
-    }
-    mod7(n) {
-        return this.d.hasModOperator ? `(${n})%7` : `MOD(${n},7)`;
-    }
-    moment(m) {
-        switch (m.moment) {
-            case 'now': {
-                const now = this.nowExpr();
-                return { begin: now, end: now.sql };
-            }
-            case 'literal':
-                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);
-                // Now the end is one unit after that .. either n-1 units ago or n+1 units from now
-                if (m.moment === 'ago' && m.n === '1') {
-                    return { begin: beginExpr, end: nowTruncExpr.sql };
-                }
-                const oneDifferent = Number(m.n) + (m.moment === 'ago' ? -1 : 1);
-                const endExpr = {
-                    ...beginExpr,
-                    kids: { base: nowTrunc, delta: this.n(oneDifferent.toString()) },
-                };
-                return { begin: beginExpr, end: this.d.sqlAlterTimeExpr(endExpr) };
-            }
-            case 'today':
-                return this.thisUnit('day');
-            case 'yesterday':
-                return this.lastUnit('day');
-            case 'tomorrow':
-                return this.nextUnit('day');
-            case 'this':
-                return this.thisUnit(m.units);
-            case 'last':
-                return this.lastUnit(m.units);
-            case 'next':
-                return this.nextUnit(m.units);
-            case 'monday':
-            case 'tuesday':
-            case 'wednesday':
-            case 'thursday':
-            case 'friday':
-            case 'saturday':
-            case 'sunday': {
-                const destDay = [
-                    'sunday',
-                    'monday',
-                    'tuesday',
-                    'wednesday',
-                    'thursday',
-                    'friday',
-                    'saturday',
-                ].indexOf(m.moment);
-                const dow = this.dayofWeek(this.nowExpr()).sql;
-                if (m.which === 'next') {
-                    const nForwards = `${this.mod7(`${destDay}-(${dow}-1)+6`)}+1`;
-                    const begin = this.delta(this.thisUnit('day').begin, '+', nForwards, 'day');
-                    const end = this.delta(this.thisUnit('day').begin, '+', `${nForwards}+1`, 'day');
-                    // console.log(
-                    //   `SELECT ${
-                    //     this.nowExpr().sql
-                    //   } as now,\n  ${destDay} as destDay,\n  ${dow} as dow,\n  ${nForwards} as nForwards,\n  ${
-                    //     begin.sql
-                    //   } as begin,\n   ${end.sql} as end`
-                    // );
-                    return { begin, end: end.sql };
-                }
-                // dacks back = mod((daw0 - dst) + 6, 7) + 1;
-                // dacks back = mod(((daw - 1) - dst) + 6, 7) + 1;
-                // dacks back = mod(((daw) - dst) + 7, 7) + 1;
-                const nBack = `${this.mod7(`(${dow}-1)-${destDay}+6`)}+1`;
-                const begin = this.delta(this.thisUnit('day').begin, '-', nBack, 'day');
-                const end = this.delta(this.thisUnit('day').begin, '-', `(${nBack})-1`, 'day');
-                // console.log(
-                //   `SELECT ${
-                //     this.nowExpr().sql
-                //   } as now,\n  ${destDay} as destDay,\n  ${dow} as dow,\n  ${nBack} as nBack,\n  ${
-                //     begin.sql
-                //   } as begin,\n   ${end.sql} as end`
-                // );
-                return { begin, end: end.sql };
-            }
-        }
-    }
-    isIn(notIn, begin, end) {
-        let begOp = '>=';
-        let endOp = '<';
-        let joinOp = 'AND';
-        if (notIn) {
-            joinOp = 'OR';
-            begOp = '<';
-            endOp = '>=';
-        }
-        begin = this.time(begin);
-        end = this.time(end);
-        return `${this.expr} ${begOp} ${begin} ${joinOp} ${this.expr} ${endOp} ${end}`;
-    }
-}
-exports.TemporalFilterCompiler = TemporalFilterCompiler;
-//# sourceMappingURL=filter_temporal_compiler.js.map