@malloydata/malloy-filter 0.0.237-dev250222034547 → 0.0.237-dev250222205057

package/src/string_parser.ts

@@ -1,7 +1,8 @@
 import {SpecialToken, Tokenizer, TokenizerParams} from './tokenizer';
 import {
   StringClause,
-  StringOperator,
+  StringCondition,
+  StringConditionOperator,
   QuoteType,
   FilterError,
   StringParserResponse,
@@ -49,17 +50,13 @@ export class StringParser extends BaseParser {
       const token = this.getNext();
       if (token.type === ',') {
         this.index++;
-      } else if (token.type === 'NULL') {
-        clauses.push({operator: '=', values: [null]});
-        this.index++;
-      } else if (token.type === 'EMPTY') {
-        clauses.push({operator: 'EMPTY', values: [null]});
-        this.index++;
-      } else if (token.type === 'NOTNULL') {
-        clauses.push({operator: '!=', values: [null]});
-        this.index++;
-      } else if (token.type === 'NOTEMPTY') {
-        clauses.push({operator: 'NOTEMPTY', values: [null]});
+      } else if (
+        token.type === 'NULL' ||
+        token.type === 'NOTNULL' ||
+        token.type === 'EMPTY' ||
+        token.type === 'NOTEMPTY'
+      ) {
+        clauses.push({operator: token.type});
         this.index++;
       } else if (this.checkSimpleWord(clauses)) {
         this.index++;
@@ -72,7 +69,15 @@ export class StringParser extends BaseParser {
         this.index++;
       }
     }
-    return {clauses: StringParser.groupClauses(clauses), errors};
+    const response: StringParserResponse = {
+      clauses: StringParser.groupClauses(clauses),
+      errors,
+    };
+    const quotes: QuoteType[] = StringParser.findQuotes(this.inputString);
+    if (quotes.length > 0) {
+      response.quotes = quotes;
+    }
+    return response;
   }
 
   private static findQuotes(str: string): QuoteType[] {
@@ -131,11 +136,16 @@ export class StringParser extends BaseParser {
     let previous: StringClause = clauses[0];
     const outputs: StringClause[] = [previous];
     for (let i = 1; i < clauses.length; i++) {
-      if (previous.operator === clauses[i].operator) {
-        previous.values.push(...clauses[i].values);
+      const current = clauses[i];
+      if (
+        previous.operator === current.operator &&
+        'values' in previous &&
+        'values' in current
+      ) {
+        previous.values.push(...current.values);
       } else {
-        previous = clauses[i];
-        outputs.push(previous);
+        previous = current;
+        outputs.push(current);
       }
     }
     return outputs;
@@ -166,7 +176,7 @@ export class StringParser extends BaseParser {
     const isUnderscore = StringParser.underscoreRegex.test(word);
     const isPercentMiddle = StringParser.percentInMiddle(word);
 
-    let operator: StringOperator = negatedMatch ? '!=' : '=';
+    let operator: StringConditionOperator = negatedMatch ? '!=' : '=';
     if (isUnderscore || isPercentMiddle || (isPercentBoth && word.length < 3)) {
       operator = negatedMatch ? '!~' : '~';
     } else if (isPercentBoth && word.length > 2) {
@@ -189,9 +199,7 @@ export class StringParser extends BaseParser {
       return false;
     }
 
-    const clause: StringClause = {operator: operator, values: [word]};
-    //const quotes: QuoteType[] = StringParser.findQuotes(word);
-    //if (quotes.length > 0) { clause.quotes = quotes; }
+    const clause: StringCondition = {operator: operator, values: [word]};
     clauses.push(clause);
     return true;
   }

package/src/string_serializer.ts

@@ -1,4 +1,8 @@
-import {StringClause, StringOperator} from './clause_types';
+import {
+  StringClause,
+  StringCondition,
+  StringConditionOperator,
+} from './clause_types';
 
 export class StringSerializer {
   constructor(private clauses: StringClause[]) {
@@ -10,9 +14,8 @@ export class StringSerializer {
     return result.trim().replace(/,$/, '');
   }
 
-  private static isNegated(operator: StringOperator): boolean {
+  private static isNegated(operator: StringConditionOperator): boolean {
     return (
-      operator === 'NOTEMPTY' ||
       operator === '!~' ||
       operator === '!=' ||
       operator === 'notStarts' ||
@@ -29,22 +32,14 @@ export class StringSerializer {
     return input.replace(/[_%]/g, match => `\\${match}`);
   }
 
-  // export type StringOperator = 'EMPTY' | 'NOTEMPTY' | 'starts' | 'ends' | 'contains' | 'notStarts' |
-  // 'notEnds' | 'notContains' | '~' | '=' | '!~' | '!=';
-  private static StringClauseToString(
-    operator: StringOperator,
-    value: string | null
+  // export type StringOperator =
+  //  | 'starts' | 'ends' | 'contains' | 'notStarts' | 'notEnds' | 'notContains'
+  //  | '~' | '=' | '!~' | '!=';
+  private static StringConditionWordToString(
+    operator: StringConditionOperator,
+    value: string
   ): string {
-    if (operator === 'EMPTY') {
-      return 'EMPTY';
-    } else if (operator === 'NOTEMPTY') {
-      return '-EMPTY';
-    }
-
     const negated: boolean = StringSerializer.isNegated(operator);
-    if (value === null) {
-      return negated ? '-NULL' : 'NULL';
-    }
     if (value === 'NULL' || value === '-NULL') {
       return (negated ? '-' : '') + '\\' + value;
     }
@@ -67,18 +62,50 @@ export class StringSerializer {
     return (negated ? '-' : '') + value;
   }
 
+  private static StringClauseToString(
+    operator:
+      | StringConditionOperator
+      | 'EMPTY'
+      | 'NOTEMPTY'
+      | 'NULL'
+      | 'NOTNULL',
+    clause: StringClause
+  ): string {
+    if (operator === 'EMPTY') {
+      return 'EMPTY';
+    } else if (operator === 'NOTEMPTY') {
+      return '-EMPTY';
+    } else if (operator === 'NULL') {
+      return 'NULL';
+    } else if (operator === 'NOTNULL') {
+      return '-NULL';
+    }
+    if (!('values' in clause) || clause.values.length === 0) {
+      return '';
+    }
+    let result = '';
+    const condition: StringCondition = clause;
+    for (const value of condition.values) {
+      const word = StringSerializer.StringConditionWordToString(
+        condition.operator,
+        value
+      );
+      if (word) {
+        result += word + ', ';
+      }
+    }
+    return result;
+  }
+
   private static clauseToString(clauses: StringClause[]): string {
     let result = '';
-    for (const genericClause of clauses) {
-      const clause: StringClause = genericClause as StringClause;
-      for (const value of clause.values) {
-        const word = StringSerializer.StringClauseToString(
-          clause.operator,
-          value
-        );
-        if (word) {
-          result += word + ', ';
-        }
+    for (const clause of clauses) {
+      const words = StringSerializer.StringClauseToString(
+        clause.operator,
+        clause
+      );
+      if (words) {
+        result += words + ', ';
       }
     }
     return result;