Merge pull request #84 from paustint/bug-83

DISTANCE with GEOLOCATION throw errors #83

Author: paustint

CHANGELOG.md

@@ -1,12 +1,22 @@
 # Changelog
 
+## 2.2.0
+
+Nov 6, 2019
+
+1. `DISTANCE` and `GEOLOCATION` functions failed to parse when used in a `WHERE` clauses and `ORDER BY` clauses.
+
 ## 2.1.0
 
+Oct 28, 2019
+
 1. The method signature for `getFlattenedFields` has changed to allow `Query | Subquery | FieldSubquery` to be passed in. this is not being considered a breaking change because it is fully backwards compatible.
 2. A new helper method `isFieldSubquery(value: any)` was added to allow determining if a Field is a FieldSubquery. This is used internally for `getFlattenedFields()`.
 
 ## 2.0.0
 
+Oct 6, 2019
+
 ### Summary
 
 Version 2.0 brings some significant bundle size and performance improvements. This library now uses [Chevrotain](https://github.com/SAP/chevrotain) instead of [antlr4](https://github.com/antlr/antlr4). With this change, everything related to parsing had to be re-written from scratch. Chevrotain uses pure javascript to handle lexing, parsing, and visiting the generated ast/cst as opposed to using a grammar file and generating a javascript parser based on the grammar.

docs/src/components/sample-queries-json.json

@@ -85,5 +85,8 @@
   "SELECT Id, Amount FROM Opportunity WHERE Amount IN (usd500.01, usd600)",
   "SELECT Name, COUNT(Id) FROM Account GROUP BY Name HAVING COUNT(Id) > 0 AND (Name LIKE '%testing%' OR Name LIKE '%123%')",
   "SELECT Name, COUNT(Id) FROM Account GROUP BY Name HAVING COUNT(Id) > 0 AND (Name IN ('4/30 testing account', 'amendment quote doc testing', null))",
-  "SELECT Name, COUNT(Id) FROM Account GROUP BY Name HAVING COUNT(Id) > 0 AND (NOT Name IN ('4/30 testing account', 'amendment quote doc testing'))"
+  "SELECT Name, COUNT(Id) FROM Account GROUP BY Name HAVING COUNT(Id) > 0 AND (NOT Name IN ('4/30 testing account', 'amendment quote doc testing'))",
+  "SELECT Name, Location__c FROM Warehouse__c WHERE DISTANCE(Location__c, GEOLOCATION(37.775, -122.418), 'mi') < 20",
+  "SELECT Name, StreetAddress__c FROM Warehouse__c WHERE DISTANCE(Location__c, GEOLOCATION(37.775, -122.418), 'mi') < 20 ORDER BY DISTANCE(Location__c, GEOLOCATION(37.775, -122.418), 'mi') LIMIT 10",
+  "SELECT Id, Name, Location, DISTANCE(Location, GEOLOCATION(10, 10), 'mi') FROM CONTACT"
 ]

src/composer/composer.ts

@@ -248,7 +248,7 @@ export class Compose {
           if (field.parameters) {
             params = field.parameters
               .map(param => (utils.isString(param) ? param : this.parseFields([param as FieldFunctionExpression])))
-              .join(',');
+              .join(', ');
           }
           return `${field.functionName}(${params})${field.alias ? ` ${field.alias}` : ''}`;
         }

src/models.ts

@@ -129,7 +129,12 @@ export interface OrderByExpressionContext extends WithIdentifier {
 
 export interface OrderByFunctionExpressionContext extends WithIdentifier {
   fn: IToken[];
-  alias?: IToken[];
+  order?: IToken[];
+  nulls?: IToken[];
+}
+
+export interface OrderByLocationExpressionContext {
+  locationFunction: CstNode[];
   order?: IToken[];
   nulls?: IToken[];
 }
@@ -161,6 +166,17 @@ export interface FieldFunctionContext {
   fn: IToken[];
 }
 
+export interface LocationFunctionContext {
+  location1: IToken[];
+  location2: IToken[] | CstNode[];
+  unit: IToken[];
+}
+
+export interface GeoLocationFunctionContext {
+  latitude: IToken[];
+  longitude: IToken[];
+}
+
 export interface ExpressionContext {
   logicalPrefix?: IToken[];
   lhs: IToken[] | CstNode[];
@@ -183,8 +199,8 @@ export interface FromClauseContext extends WithIdentifier {
   alias?: IToken[];
 }
 
-export interface FunctionExpressionContext extends WithIdentifier {
-  fn?: CstNode[];
+export interface FunctionExpressionContext {
+  params?: (CstNode | IToken)[];
 }
 
 export interface AtomicExpressionContext {

src/parser/lexer.ts

@@ -385,6 +385,7 @@ export const Distance = createToken({
   longer_alt: Identifier,
   categories: [LocationFunction, Identifier],
 });
+
 export const Geolocation = createToken({
   name: 'GEOLOCATION',
   pattern: /GEOLOCATION/i,
@@ -746,6 +747,13 @@ export const SignedInteger = createToken({
   pattern: /(\-|\+)[0-9]+/,
   categories: [NumberIdentifier, IntegerNumberIdentifier],
 });
+export const GeolocationUnit = createToken({
+  name: 'GEOLOCATION_UNIT',
+  pattern: /'(mi|km)'/,
+  longer_alt: Identifier,
+  categories: [Identifier],
+});
+
 export const UnsignedInteger = createToken({
   name: 'UNSIGNED_INTEGER',
   pattern: /0|[1-9]\d*/,
@@ -949,6 +957,8 @@ export const allTokens = [
   LastNFiscalYears,
   NFiscalYearsAgo,
 
+  GeolocationUnit,
+
   In,
   NotIn,
   For,

src/parser/parser.ts

@@ -201,7 +201,7 @@ export class SoqlParser extends CstParser {
     const parenCount = this.getParenCount();
     this.AT_LEAST_ONE({
       DEF: () => {
-        this.SUBRULE(this.conditionExpression, { ARGS: [parenCount, false, true] });
+        this.SUBRULE(this.conditionExpression, { ARGS: [parenCount, false, true, true] });
       },
     });
 
@@ -220,7 +220,7 @@ export class SoqlParser extends CstParser {
 
   private conditionExpression = this.RULE(
     'conditionExpression',
-    (parenCount?: ParenCount, allowSubquery?: boolean, alowAggregateFn?: boolean) => {
+    (parenCount?: ParenCount, allowSubquery?: boolean, alowAggregateFn?: boolean, allowLocationFn?: boolean) => {
       // argument is undefined during self-analysis, need to initialize to avoid exception
       parenCount = this.getParenCount(parenCount);
       this.OPTION(() => {
@@ -229,7 +229,7 @@ export class SoqlParser extends CstParser {
           { ALT: () => this.CONSUME(lexer.Or, { LABEL: 'logicalOperator' }) },
         ]);
       });
-      this.SUBRULE(this.expression, { ARGS: [parenCount, allowSubquery, alowAggregateFn] });
+      this.SUBRULE(this.expression, { ARGS: [parenCount, allowSubquery, alowAggregateFn, allowLocationFn] });
     },
   );
 
@@ -314,6 +314,7 @@ export class SoqlParser extends CstParser {
       DEF: () => {
         this.OR([
           { ALT: () => this.SUBRULE(this.orderByFunctionExpression, { LABEL: 'orderByExpressionOrFn' }) },
+          { ALT: () => this.SUBRULE(this.orderByLocationExpression, { LABEL: 'orderByExpressionOrFn' }) },
           { ALT: () => this.SUBRULE(this.orderByExpression, { LABEL: 'orderByExpressionOrFn' }) },
         ]);
       },
@@ -336,6 +337,17 @@ export class SoqlParser extends CstParser {
     this.SUBRULE(this.functionExpression);
   });
 
+  private orderByLocationExpression = this.RULE('orderByLocationExpression', () => {
+    this.SUBRULE(this.locationFunction);
+    this.OPTION(() => {
+      this.OR([{ ALT: () => this.CONSUME(lexer.Asc, { LABEL: 'order' }) }, { ALT: () => this.CONSUME(lexer.Desc, { LABEL: 'order' }) }]);
+    });
+    this.OPTION1(() => {
+      this.CONSUME(lexer.Nulls);
+      this.OR1([{ ALT: () => this.CONSUME(lexer.First, { LABEL: 'nulls' }) }, { ALT: () => this.CONSUME(lexer.Last, { LABEL: 'nulls' }) }]);
+    });
+  });
+
   private limitClause = this.RULE('limitClause', () => {
     this.CONSUME(lexer.Limit);
     this.CONSUME(lexer.UnsignedInteger, { LABEL: 'value' });
@@ -385,11 +397,6 @@ export class SoqlParser extends CstParser {
     this.SUBRULE(this.functionExpression, { ARGS: [true] });
   });
 
-  private locationFunction = this.RULE('locationFunction', () => {
-    this.OR([{ ALT: () => this.CONSUME(lexer.Distance) }, { ALT: () => this.CONSUME(lexer.Geolocation) }]);
-    this.SUBRULE(this.functionExpression);
-  });
-
   private otherFunction = this.RULE('otherFunction', () => {
     this.OR(
       this.$_otherFunction ||
@@ -420,53 +427,81 @@ export class SoqlParser extends CstParser {
       SEP: lexer.Comma,
       DEF: () => {
         this.OR([
-          { GATE: () => !skipAggregate, ALT: () => this.SUBRULE(this.aggregateFunction, { LABEL: 'fn' }) },
-          { ALT: () => this.SUBRULE(this.locationFunction, { LABEL: 'fn' }) },
-          { ALT: () => this.SUBRULE(this.otherFunction, { LABEL: 'fn' }) },
-          { ALT: () => this.CONSUME(lexer.Identifier) },
+          { GATE: () => !skipAggregate, ALT: () => this.SUBRULE(this.aggregateFunction, { LABEL: 'params' }) },
+          { ALT: () => this.SUBRULE(this.otherFunction, { LABEL: 'params' }) },
+          { ALT: () => this.CONSUME(lexer.StringIdentifier, { LABEL: 'params' }) },
+          { ALT: () => this.CONSUME(lexer.NumberIdentifier, { LABEL: 'params' }) },
+          { ALT: () => this.CONSUME(lexer.Identifier, { LABEL: 'params' }) },
         ]);
       },
     });
     this.CONSUME(lexer.RParen);
   });
 
-  private expression = this.RULE('expression', (parenCount?: ParenCount, allowSubquery?: boolean, alowAggregateFn?: boolean) => {
-    this.OPTION(() => {
-      this.MANY(() => {
-        this.CONSUME(lexer.LParen);
-        if (parenCount) {
-          parenCount.left++;
-        }
-      });
-    });
-
-    this.OPTION1(() => {
-      this.CONSUME(lexer.Not, { LABEL: 'logicalPrefix' });
-    });
-
-    this.OR1([
-      { GATE: () => alowAggregateFn, ALT: () => this.SUBRULE(this.aggregateFunction, { LABEL: 'lhs' }) },
-      { ALT: () => this.SUBRULE(this.otherFunction, { LABEL: 'lhs' }) },
-      { ALT: () => this.CONSUME(lexer.Identifier, { LABEL: 'lhs' }) },
+  private locationFunction = this.RULE('locationFunction', () => {
+    this.CONSUME(lexer.Distance);
+    this.CONSUME(lexer.LParen);
+    this.CONSUME(lexer.Identifier, { LABEL: 'location1' });
+    this.CONSUME(lexer.Comma);
+    this.OR([
+      { ALT: () => this.SUBRULE(this.geolocationFunction, { LABEL: 'location2' }) },
+      { ALT: () => this.CONSUME1(lexer.Identifier, { LABEL: 'location2' }) },
     ]);
+    this.CONSUME1(lexer.Comma);
+    this.CONSUME(lexer.GeolocationUnit, { LABEL: 'unit' });
+    this.CONSUME(lexer.RParen);
+  });
 
-    this.OR2([
-      { ALT: () => this.SUBRULE(this.expressionWithRelationalOperator, { LABEL: 'operator' }) },
-      { ALT: () => this.SUBRULE(this.expressionWithSetOperator, { LABEL: 'operator', ARGS: [allowSubquery] }) },
-    ]);
+  private geolocationFunction = this.RULE('geolocationFunction', () => {
+    this.CONSUME(lexer.Geolocation);
+    this.CONSUME(lexer.LParen);
+    this.CONSUME(lexer.NumberIdentifier, { LABEL: 'latitude' });
+    this.CONSUME(lexer.Comma);
+    this.CONSUME1(lexer.NumberIdentifier, { LABEL: 'longitude' });
+    this.CONSUME(lexer.RParen);
+  });
 
-    this.OPTION4(() => {
-      this.MANY1({
-        GATE: () => (parenCount ? parenCount.left > parenCount.right : true),
-        DEF: () => {
-          this.CONSUME(lexer.RParen);
+  private expression = this.RULE(
+    'expression',
+    (parenCount?: ParenCount, allowSubquery?: boolean, alowAggregateFn?: boolean, allowLocationFn?: boolean) => {
+      this.OPTION(() => {
+        this.MANY(() => {
+          this.CONSUME(lexer.LParen);
           if (parenCount) {
-            parenCount.right++;
+            parenCount.left++;
           }
-        },
+        });
       });
-    });
-  });
+
+      this.OPTION1(() => {
+        this.CONSUME(lexer.Not, { LABEL: 'logicalPrefix' });
+      });
+
+      this.OR1([
+        { GATE: () => alowAggregateFn, ALT: () => this.SUBRULE(this.aggregateFunction, { LABEL: 'lhs' }) },
+        { GATE: () => allowLocationFn, ALT: () => this.SUBRULE(this.locationFunction, { LABEL: 'lhs' }) },
+        { ALT: () => this.SUBRULE(this.otherFunction, { LABEL: 'lhs' }) },
+        { ALT: () => this.CONSUME(lexer.Identifier, { LABEL: 'lhs' }) },
+      ]);
+
+      this.OR2([
+        { ALT: () => this.SUBRULE(this.expressionWithRelationalOperator, { LABEL: 'operator' }) },
+        { ALT: () => this.SUBRULE(this.expressionWithSetOperator, { LABEL: 'operator', ARGS: [allowSubquery] }) },
+      ]);
+
+      this.OPTION4(() => {
+        this.MANY1({
+          GATE: () => (parenCount ? parenCount.left > parenCount.right : true),
+          DEF: () => {
+            this.CONSUME(lexer.RParen);
+            if (parenCount) {
+              parenCount.right++;
+            }
+          },
+        });
+      });
+    },
+  );
 
   private expressionWithRelationalOperator = this.RULE('expressionWithRelationalOperator', () => {
     this.SUBRULE(this.relationalOperator);