@malloydata/malloy-filter 0.0.237-dev250224203840 → 0.0.237-dev250225015031

package/src/date_parser.ts

@@ -1,3 +1,10 @@
+/*
+ * 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.
+ */
+
 import {SpecialToken, Tokenizer, TokenizerParams} from './tokenizer';
 import {
   DateTimeUnit,
@@ -21,9 +28,9 @@ import {
 } from './date_types';
 import {BaseParser} from './base_parser';
 import {Token} from './token_types';
-import {FilterError} from './clause_types';
+import {FilterLog} from './clause_types';
 
-type DatePrefix = 'BEFORE' | 'AFTER';
+type DatePrefix = 'before' | 'after';
 
 export class DateParser extends BaseParser {
   private static readonly yearRegex: RegExp = /[%_]/;
@@ -35,38 +42,49 @@ export class DateParser extends BaseParser {
 
   private tokenize(): void {
     const specialSubstrings: SpecialToken[] = [{type: ',', value: ','}];
+    // Do not reorder.
     const specialWords: SpecialToken[] = [
       {
-        type: 'UNITOFTIME',
+        type: 'unitoftime',
         value: /^(second|minute|hour|day|week|month|quarter|year)s?$/i,
         ignoreCase: true,
       },
       {
-        type: 'DAYOFWEEK',
+        type: 'dayofweek',
         value: /^(monday|tuesday|wednesday|thursday|friday|saturday|sunday)$/i,
         ignoreCase: true,
       },
-      {type: 'DATE', value: /^\d\d\d\d-\d\d-\d\d$/},
-      {type: 'DATE', value: /^\d\d\d\d-\d\d$/},
-      {type: 'TIME', value: /^\d\d:\d\d:\d\d\.\d+$/},
-      {type: 'TIME', value: /^\d\d:\d\d:\d\d$/},
-      {type: 'TIME', value: /^\d\d:\d\d$/},
-      {type: 'NOTNULL', value: '-null', ignoreCase: true},
-      {type: 'NULL', value: 'null', ignoreCase: true},
-      {type: 'PREFIX', value: /^(before|after)/i, ignoreCase: true},
-      {type: 'TODAY', value: 'today', ignoreCase: true},
-      {type: 'YESTERDAY', value: 'yesterday', ignoreCase: true},
-      {type: 'TOMORROW', value: 'tomorrow', ignoreCase: true},
-      {type: 'NOW', value: 'now', ignoreCase: true},
-      {type: 'THIS', value: 'this', ignoreCase: true},
-      {type: 'LAST', value: 'last', ignoreCase: true},
-      {type: 'NEXT', value: 'next', ignoreCase: true},
-      {type: 'AGO', value: 'ago', ignoreCase: true},
-      {type: 'FROM', value: 'from', ignoreCase: true},
-      {type: 'FOR', value: 'for', ignoreCase: true},
-      {type: 'TO', value: 'to', ignoreCase: true},
-      {type: 'YEAR', value: /^\d\d\d\d$/}, // Years are ambiguous, and require special handling.
-      {type: 'NUMBER', value: /^[\d.]+/, ignoreCase: true},
+      {type: 'date', value: /^\d{4}-\d{2}-\d{2}T\d\d$/},
+      {type: 'date', value: /^\d{4}-\d{2}-\d{2}$/},
+      {type: 'date', value: /^\d{4}-\d{2}$/},
+      {type: 'date', value: /^\d{4}-[Qq][1234]$/},
+      {
+        type: 'date',
+        value: /^\d{4}-\d{2}-\d{2}T\d\d:\d\d:\d\d\[[a-zA-Z_/]*\]$/,
+      },
+      {type: 'date', value: /^\d{4}-\d{2}-\d{2}T\d\d:\d\d:\d\d[.,]\d+$/},
+      {type: 'date', value: /^\d{4}-\d{2}-\d{2}T\d\d:\d\d:\d\d$/},
+      {type: 'date', value: /^\d{4}-\d{2}-\d{2}T\d\d:\d\d$/},
+      {type: 'time', value: /^\d\d:\d\d:\d\d\[[a-zA-Z_/]*\]$/},
+      {type: 'time', value: /^\d\d:\d\d:\d\d[.,]\d+$/},
+      {type: 'time', value: /^\d\d:\d\d:\d\d$/},
+      {type: 'time', value: /^\d\d:\d\d$/},
+      {type: 'not_null', value: '-null', ignoreCase: true},
+      {type: 'null', value: 'null', ignoreCase: true},
+      {type: 'prefix', value: /^(before|after)/i, ignoreCase: true},
+      {type: 'today', value: 'today', ignoreCase: true},
+      {type: 'yesterday', value: 'yesterday', ignoreCase: true},
+      {type: 'tomorrow', value: 'tomorrow', ignoreCase: true},
+      {type: 'now', value: 'now', ignoreCase: true},
+      {type: 'this', value: 'this', ignoreCase: true},
+      {type: 'last', value: 'last', ignoreCase: true},
+      {type: 'next', value: 'next', ignoreCase: true},
+      {type: 'ago', value: 'ago', ignoreCase: true},
+      {type: 'from', value: 'from', ignoreCase: true},
+      {type: 'for', value: 'for', ignoreCase: true},
+      {type: 'to', value: 'to', ignoreCase: true},
+      {type: 'year', value: /^\d\d\d\d$/}, // Years are ambiguous, and require special handling.
+      {type: 'number', value: /^[\d.]+/, ignoreCase: true},
     ];
     const params: TokenizerParams = {
       trimWordWhitespace: true,
@@ -77,37 +95,62 @@ export class DateParser extends BaseParser {
 
     const tokenizer = new Tokenizer(this.inputString, params);
     this.tokens = tokenizer.parse();
-    // console.log('Tokens before moments ', ...this.tokens);
+    this.tokens = this.mergeDateTimeTokens();
     this.tokens = this.mergeMomentTokens();
   }
 
+  private mergeDateTimeTokens(): Token[] {
+    const output: Token[] = [];
+    this.index = 0;
+    let previous: Token | undefined = undefined;
+    while (this.index < this.tokens.length) {
+      const token = this.tokens[this.index];
+      if (
+        previous &&
+        previous.type === 'date' &&
+        previous.value.length >= 10 &&
+        (token.type === 'time' ||
+          (token.type === 'number' && token.value.length === 2))
+      ) {
+        previous.value = previous.value + ' ' + token.value;
+        previous.endIndex = token.endIndex;
+        previous = undefined;
+      } else {
+        previous = token;
+        output.push(token);
+      }
+      this.index++;
+    }
+    return output;
+  }
+
   private mergeMomentTokens(): Token[] {
     const output: Token[] = [];
     this.index = 0;
     while (this.index < this.tokens.length) {
+      // Do not reorder.
       if (
-        this.matchAndMerge('LAST|UNITOFTIME', output) ||
-        this.matchAndMerge('LAST|DAYOFWEEK', output) ||
-        this.matchAndMerge('LAST|NUMBER|UNITOFTIME', output) ||
-        this.matchAndMerge('LAST|YEAR|UNITOFTIME', output) ||
-        this.matchAndMerge('THIS|UNITOFTIME', output) ||
-        this.matchAndMerge('NEXT|UNITOFTIME', output) ||
-        this.matchAndMerge('NEXT|DAYOFWEEK', output) ||
-        this.matchAndMerge('NEXT|NUMBER|UNITOFTIME', output) ||
-        this.matchAndMerge('NEXT|YEAR|UNITOFTIME', output) ||
-        this.matchAndMerge('NUMBER|UNITOFTIME|AGO', output) ||
-        this.matchAndMerge('YEAR|UNITOFTIME|AGO', output) ||
-        this.matchAndMerge('NUMBER|UNITOFTIME|FROM|NOW', output) ||
-        this.matchAndMerge('YEAR|UNITOFTIME|FROM|NOW', output) ||
-        this.matchAndMerge('NUMBER|UNITOFTIME', output) ||
-        this.matchAndMerge('YEAR|UNITOFTIME', output) ||
-        this.matchAndMerge('DATE|TIME', output) ||
-        this.matchAndMerge('TODAY', output) ||
-        this.matchAndMerge('YESTERDAY', output) ||
-        this.matchAndMerge('TOMORROW', output) ||
-        this.matchAndMerge('DATE', output) ||
-        this.matchAndMerge('YEAR', output) ||
-        this.matchAndMerge('NOW', output)
+        this.matchAndMerge('last|unitoftime', output) ||
+        this.matchAndMerge('last|dayofweek', output) ||
+        this.matchAndMerge('last|number|unitoftime', output) ||
+        this.matchAndMerge('last|year|unitoftime', output) ||
+        this.matchAndMerge('this|unitoftime', output) ||
+        this.matchAndMerge('next|unitoftime', output) ||
+        this.matchAndMerge('next|dayofweek', output) ||
+        this.matchAndMerge('next|number|unitoftime', output) ||
+        this.matchAndMerge('next|year|unitoftime', output) ||
+        this.matchAndMerge('number|unitoftime|ago', output) ||
+        this.matchAndMerge('year|unitoftime|ago', output) ||
+        this.matchAndMerge('number|unitoftime|from|now', output) ||
+        this.matchAndMerge('year|unitoftime|from|now', output) ||
+        this.matchAndMerge('number|unitoftime', output) ||
+        this.matchAndMerge('year|unitoftime', output) ||
+        this.matchAndMerge('today', output) ||
+        this.matchAndMerge('yesterday', output) ||
+        this.matchAndMerge('tomorrow', output) ||
+        this.matchAndMerge('date', output) ||
+        this.matchAndMerge('year', output) ||
+        this.matchAndMerge('now', output)
       ) {
         continue;
       } else {
@@ -139,25 +182,34 @@ export class DateParser extends BaseParser {
     this.tokenize();
     let prefix: DatePrefix | undefined = undefined;
     const clauses: DateClause[] = [];
-    const errors: FilterError[] = [];
+    const logs: FilterLog[] = [];
     this.index = 0;
     while (this.index < this.tokens.length) {
       const token = this.getNext();
       if (token.type === ',') {
         if (prefix) {
-          errors.push({
+          logs.push({
+            severity: 'error',
             message: 'Invalid ' + prefix,
             startIndex: token.startIndex,
             endIndex: token.endIndex,
           });
+        } else if (this.index > 0 && this.tokens[this.index - 1].type === ',') {
+          logs.push({
+            severity: 'warn',
+            message: 'Empty clause',
+            startIndex: token.startIndex,
+            endIndex: token.endIndex,
+          });
         }
         this.index++;
-      } else if (token.type === 'PREFIX') {
+      } else if (token.type === 'prefix') {
         prefix = token.value as DatePrefix;
         this.index++;
       } else if (this.handleRange(clauses)) {
         if (prefix) {
-          errors.push({
+          logs.push({
+            severity: 'error',
             message: 'Invalid ' + prefix,
             startIndex: token.startIndex,
             endIndex: token.endIndex,
@@ -166,8 +218,13 @@ export class DateParser extends BaseParser {
         }
       } else if (this.handleMerged(prefix, clauses)) {
         prefix = undefined;
+      } else if (token.type === 'null' || token.type === 'not_null') {
+        prefix = undefined;
+        clauses.push({operator: token.type});
+        this.index++;
       } else {
-        errors.push({
+        logs.push({
+          severity: 'error',
           message:
             'Invalid token ' + token.value ||
             (token.values ? token.values.join(' ') : ''),
@@ -178,7 +235,7 @@ export class DateParser extends BaseParser {
         this.index++;
       }
     }
-    return {clauses, errors};
+    return {clauses, logs};
   }
 
   private static createMomentClause(
@@ -186,11 +243,11 @@ export class DateParser extends BaseParser {
     moment: DateMoment
   ): DateClause {
     if (!prefix) {
-      return {operator: 'ON', moment}; // DateOnClause
-    } else if (prefix === 'BEFORE') {
-      return {operator: 'BEFORE', moment}; // DateBeforeClause
+      return {operator: 'on', moment}; // DateOnClause
+    } else if (prefix === 'before') {
+      return {operator: 'before', moment}; // DateBeforeClause
     } else {
-      return {operator: 'AFTER', moment}; // DateAfterClause
+      return {operator: 'after', moment}; // DateAfterClause
     }
   }
 
@@ -204,7 +261,7 @@ export class DateParser extends BaseParser {
     const unit: DateTimeUnit | DateWeekday = tokens[1].value as
       | DateTimeUnit
       | DateWeekday;
-    const moment: IntervalMoment = {type: 'INTERVAL', kind, unit};
+    const moment: IntervalMoment = {type: 'interval', kind, unit};
     return DateParser.createMomentClause(prefix, moment);
   }
 
@@ -217,12 +274,12 @@ export class DateParser extends BaseParser {
     const amount = Number(tokens[0].value);
     const unit: DateTimeUnit = tokens[1].value as DateTimeUnit;
     const direction: DateMomentOffsetFromNowDirection =
-      tokens[2].type === 'AGO' ? 'AGO' : 'FROMNOW';
+      tokens[2].type === 'ago' ? 'ago' : 'from_now';
     if (!DateParser.isValidNumber(amount)) {
       return undefined;
     }
     const moment: OffsetMoment = {
-      type: 'OFFSET_FROM_NOW',
+      type: 'offset_from_now',
       direction,
       amount,
       unit,
@@ -238,11 +295,11 @@ export class DateParser extends BaseParser {
     const amount = Number(tokens[0].value);
     const unit: DateTimeUnit = tokens[1].value as DateTimeUnit;
     const direction: DateMomentSpanFromNowDirection =
-      tokens[2].type === 'LAST' ? 'LAST' : 'NEXT';
+      tokens[2].type === 'last' ? 'last' : 'next';
     if (!DateParser.isValidNumber(amount)) {
       return undefined;
     }
-    const moment: SpanMoment = {type: 'SPAN_FROM_NOW', direction, amount, unit};
+    const moment: SpanMoment = {type: 'span_from_now', direction, amount, unit};
     return DateParser.createMomentClause(prefix, moment);
   }
 
@@ -254,7 +311,7 @@ export class DateParser extends BaseParser {
     if (prefix) {
       return undefined; // before 7 hours is ambiguous, not allowed.
     }
-    const operator = 'DURATION';
+    const operator = 'duration';
     const amount = Number(tokens[0].value);
     const unit: DateTimeUnit = tokens[1].value as DateTimeUnit;
     if (!DateParser.isValidNumber(amount)) {
@@ -269,19 +326,27 @@ export class DateParser extends BaseParser {
     prefix: DatePrefix | undefined,
     tokens: Token[]
   ): DateClause {
-    let unit: DateTimeUnit = 'YEAR';
-    let date = tokens[0].value;
-    if (tokens.length === 2) {
-      const timeStr = tokens[1].value;
-      date += ' ' + timeStr;
-      if (timeStr.length > 5) unit = 'SECOND';
-      else unit = 'MINUTE';
-    } else if (date.length > 7) {
-      unit = 'DAY';
-    } else if (date.length > 4) {
-      unit = 'MONTH';
+    const dateStr = tokens[0].value;
+    const matcher: RegExpExecArray | null = /^\d{4}-\d{2}-\d{2}[Tt ](.+)$/.exec(
+      dateStr
+    );
+    const timeStr = matcher ? matcher[1] : '';
+
+    let unit: DateTimeUnit = 'year';
+    if (timeStr.length > 8) {
+      unit = 'instant';
+    } else if (timeStr.length > 5) {
+      unit = 'second';
+    } else if (timeStr.length > 2) {
+      unit = 'minute';
+    } else if (timeStr.length === 2) {
+      unit = 'hour';
+    } else if (dateStr.length > 7) {
+      unit = 'day';
+    } else if (dateStr.length > 4) {
+      unit = /[qQ]/.test(dateStr) ? 'quarter' : 'month';
     }
-    const moment: AbsoluteMoment = {type: 'ABSOLUTE', date, unit};
+    const moment: AbsoluteMoment = {type: 'absolute', date: dateStr, unit};
     return DateParser.createMomentClause(prefix, moment);
   }
 
@@ -290,19 +355,19 @@ export class DateParser extends BaseParser {
     prefix: DatePrefix | undefined,
     tokens: Token[]
   ): DateClause {
-    let momentName: DateMomentName = 'NOW';
+    let momentName: DateMomentName = 'now';
     switch (tokens[0].type) {
-      case 'TODAY':
-        momentName = 'TODAY';
+      case 'today':
+        momentName = 'today';
         break;
-      case 'YESTERDAY':
-        momentName = 'YESTERDAY';
+      case 'yesterday':
+        momentName = 'yesterday';
         break;
-      case 'TOMORROW':
-        momentName = 'TOMORROW';
+      case 'tomorrow':
+        momentName = 'tomorrow';
         break;
     }
-    const moment: NamedMoment = {type: 'NAMED', name: momentName};
+    const moment: NamedMoment = {type: 'named', name: momentName};
     return DateParser.createMomentClause(prefix, moment);
   }
 
@@ -315,8 +380,8 @@ export class DateParser extends BaseParser {
       return undefined;
     }
     if (
-      token.type === 'MERGE:NUMBER|UNITOFTIME' ||
-      token.type === 'MERGE:YEAR|UNITOFTIME'
+      token.type === 'MERGE:number|unitoftime' ||
+      token.type === 'MERGE:year|unitoftime'
     ) {
       const value = Number(token.values[0].value);
       if (!DateParser.isValidNumber(value)) {
@@ -334,33 +399,32 @@ export class DateParser extends BaseParser {
   ): DateClause | undefined {
     const tokens: Token[] = token.values || [];
     switch (token.type) {
-      case 'MERGE:LAST|UNITOFTIME':
-      case 'MERGE:LAST|DAYOFWEEK':
-      case 'MERGE:THIS|UNITOFTIME':
-      case 'MERGE:NEXT|UNITOFTIME':
-      case 'MERGE:NEXT|DAYOFWEEK':
+      case 'MERGE:last|unitoftime':
+      case 'MERGE:last|dayofweek':
+      case 'MERGE:this|unitoftime':
+      case 'MERGE:next|unitoftime':
+      case 'MERGE:next|dayofweek':
         return this.createIntervalMoment(prefix, tokens);
-      case 'MERGE:LAST|NUMBER|UNITOFTIME':
-      case 'MERGE:LAST|YEAR|UNITOFTIME':
-      case 'MERGE:NEXT|NUMBER|UNITOFTIME':
-      case 'MERGE:NEXT|YEAR|UNITOFTIME':
+      case 'MERGE:last|number|unitoftime':
+      case 'MERGE:last|year|unitoftime':
+      case 'MERGE:next|number|unitoftime':
+      case 'MERGE:next|year|unitoftime':
         return this.createSpanMoment(prefix, tokens);
-      case 'MERGE:NUMBER|UNITOFTIME|AGO':
-      case 'MERGE:YEAR|UNITOFTIME|AGO':
-      case 'MERGE:NUMBER|UNITOFTIME|FROM|NOW':
-      case 'MERGE:YEAR|UNITOFTIME|FROM|NOW':
+      case 'MERGE:number|unitoftime|ago':
+      case 'MERGE:year|unitoftime|ago':
+      case 'MERGE:number|unitoftime|from|now':
+      case 'MERGE:year|unitoftime|from|now':
         return this.createOffsetMoment(prefix, tokens);
-      case 'MERGE:NUMBER|UNITOFTIME':
-      case 'MERGE:YEAR|UNITOFTIME':
+      case 'MERGE:number|unitoftime':
+      case 'MERGE:year|unitoftime':
         return this.createDateDuration(prefix, tokens);
-      case 'MERGE:DATE|TIME':
-      case 'MERGE:DATE':
-      case 'MERGE:YEAR':
+      case 'MERGE:date':
+      case 'MERGE:year':
         return this.createAbsoluteMoment(prefix, tokens);
-      case 'MERGE:NOW':
-      case 'MERGE:TODAY':
-      case 'MERGE:YESTERDAY':
-      case 'MERGE:TOMORROW':
+      case 'MERGE:now':
+      case 'MERGE:today':
+      case 'MERGE:yesterday':
+      case 'MERGE:tomorrow':
         return this.createNamedMoment(prefix, tokens);
       default:
         return undefined;
@@ -383,8 +447,8 @@ export class DateParser extends BaseParser {
   private handleRange(clauses: DateClause[]): boolean {
     if (
       this.isMatchingToken(this.index, 'MERGE', false) &&
-      (this.isMatchingToken(this.index + 1, 'TO', true) ||
-        this.isMatchingToken(this.index + 1, 'FOR', true)) &&
+      (this.isMatchingToken(this.index + 1, 'to', true) ||
+        this.isMatchingToken(this.index + 1, 'for', true)) &&
       this.isMatchingToken(this.index + 2, 'MERGE', false)
     ) {
       const startToken = this.tokens[this.index];
@@ -398,7 +462,7 @@ export class DateParser extends BaseParser {
       if (startClause === undefined || !('moment' in startClause)) {
         return false;
       }
-      if (operator === 'TO') {
+      if (operator === 'to') {
         const endClause = DateParser.createClauseFromMerged(
           undefined,
           endToken
@@ -407,7 +471,7 @@ export class DateParser extends BaseParser {
           return false;
         }
         const clause: DateBetweenClause = {
-          operator: 'TO_RANGE',
+          operator: 'to_range',
           from: startClause.moment,
           to: endClause.moment,
         };
@@ -418,7 +482,7 @@ export class DateParser extends BaseParser {
           return false;
         }
         const clause: DateForClause = {
-          operator: 'FOR_RANGE',
+          operator: 'for_range',
           from: startClause.moment,
           duration: endDuration,
         };
@@ -442,8 +506,6 @@ export class DateParser extends BaseParser {
       }
       clauses.push(clause);
       return true;
-    } else if (token.type === 'NULL' || token.type === 'NOTNULL') {
-      clauses.push({operator: token.type});
     }
     return false;
   }

package/src/date_serializer.ts

@@ -1,3 +1,10 @@
+/*
+ * 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.
+ */
+
 import {
   DateMoment,
   DateBetweenClause,
@@ -16,16 +23,16 @@ export class DateSerializer {
   }
 
   private static dateMomentToString(moment: DateMoment): string {
-    if (moment.type === 'ABSOLUTE') {
+    if (moment.type === 'absolute') {
       return moment.date;
-    } else if (moment.type === 'INTERVAL') {
+    } else if (moment.type === 'interval') {
       return moment.kind + ' ' + moment.unit;
-    } else if (moment.type === 'NAMED') {
+    } else if (moment.type === 'named') {
       return moment.name;
-    } else if (moment.type === 'OFFSET_FROM_NOW') {
-      const direction = moment.direction === 'FROMNOW' ? 'FROM NOW' : 'AGO';
+    } else if (moment.type === 'offset_from_now') {
+      const direction = moment.direction === 'from_now' ? 'from now' : 'ago';
       return moment.amount + ' ' + moment.unit + ' ' + direction;
-    } else if (moment.type === 'SPAN_FROM_NOW') {
+    } else if (moment.type === 'span_from_now') {
       return moment.direction + ' ' + moment.amount + ' ' + moment.unit;
     } else {
       throw new Error('moment type not recognized ' + JSON.stringify(moment));
@@ -35,7 +42,7 @@ export class DateSerializer {
   private static goDateBetweenClause(clause: DateBetweenClause): string {
     return (
       DateSerializer.dateMomentToString(clause.from) +
-      ' TO ' +
+      ' to ' +
       DateSerializer.dateMomentToString(clause.to)
     );
   }
@@ -43,7 +50,7 @@ export class DateSerializer {
   private static goDateForClause(clause: DateForClause): string {
     return (
       DateSerializer.dateMomentToString(clause.from) +
-      ' FOR ' +
+      ' for ' +
       clause.duration.amount +
       ' ' +
       clause.duration.unit
@@ -54,21 +61,21 @@ export class DateSerializer {
     if (!('operator' in clause)) {
       throw new Error('Invalid date clause ' + JSON.stringify(clause));
     }
-    if (clause.operator === 'TO_RANGE') {
+    if (clause.operator === 'to_range') {
       return DateSerializer.goDateBetweenClause(clause);
-    } else if (clause.operator === 'FOR_RANGE') {
+    } else if (clause.operator === 'for_range') {
       return DateSerializer.goDateForClause(clause);
-    } else if (clause.operator === 'BEFORE') {
-      return 'BEFORE ' + DateSerializer.dateMomentToString(clause.moment);
-    } else if (clause.operator === 'AFTER') {
-      return 'AFTER ' + DateSerializer.dateMomentToString(clause.moment);
-    } else if (clause.operator === 'ON') {
+    } else if (clause.operator === 'before') {
+      return 'before ' + DateSerializer.dateMomentToString(clause.moment);
+    } else if (clause.operator === 'after') {
+      return 'after ' + DateSerializer.dateMomentToString(clause.moment);
+    } else if (clause.operator === 'on') {
       return DateSerializer.dateMomentToString(clause.moment);
-    } else if (clause.operator === 'NULL') {
-      return 'NULL';
-    } else if (clause.operator === 'NOTNULL') {
-      return '-NULL';
-    } else if (clause.operator === 'DURATION') {
+    } else if (clause.operator === 'null') {
+      return 'null';
+    } else if (clause.operator === 'not_null') {
+      return '-null';
+    } else if (clause.operator === 'duration') {
       return clause.duration.amount + ' ' + clause.duration.unit;
     } else {
       throw new Error('Clause type not recognized ' + JSON.stringify(clause));