diff --git a/x-pack/plugin/eql/src/main/antlr/EqlBase.g4 b/x-pack/plugin/eql/src/main/antlr/EqlBase.g4
index 8e26ec9b753df..39b3de1cd5684 100644
--- a/x-pack/plugin/eql/src/main/antlr/EqlBase.g4
+++ b/x-pack/plugin/eql/src/main/antlr/EqlBase.g4
@@ -73,32 +73,27 @@ expression
 booleanExpression
     : NOT booleanExpression                                               #logicalNot
     | relationship=IDENTIFIER OF subquery                                 #processCheck
-    | predicated                                                          #booleanDefault
+    | valueExpression                                                     #booleanDefault
     | left=booleanExpression operator=AND right=booleanExpression         #logicalBinary
     | left=booleanExpression operator=OR right=booleanExpression          #logicalBinary
     ;
 
-// workaround for:
-//  https://github.com/antlr/antlr4/issues/780
-//  https://github.com/antlr/antlr4/issues/781
-predicated
-    : valueExpression predicate?
-    ;
-
-// dedicated calls for each branch are not used to reuse the NOT handling across them
-// instead the property kind is used for differentiation
-predicate
-    : NOT? kind=IN LP valueExpression (COMMA valueExpression)* RP
-    ;
 
 valueExpression
-    : primaryExpression                                                                 #valueExpressionDefault
+    : primaryExpression predicate?                                                      #valueExpressionDefault
     | operator=(MINUS | PLUS) valueExpression                                           #arithmeticUnary
     | left=valueExpression operator=(ASTERISK | SLASH | PERCENT) right=valueExpression  #arithmeticBinary
     | left=valueExpression operator=(PLUS | MINUS) right=valueExpression                #arithmeticBinary
     | left=valueExpression comparisonOperator right=valueExpression                     #comparison
     ;
 
+// workaround for
+//   https://github.com/antlr/antlr4/issues/780
+//   https://github.com/antlr/antlr4/issues/781
+predicate
+    : NOT? kind=IN LP expression (COMMA expression)* RP
+    ;
+
 primaryExpression
     : constant                                                                          #constantDefault
     | functionExpression                                                                #function
diff --git a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/AbstractBuilder.java b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/AbstractBuilder.java
index 86a81fa41f7f8..c2baf39929313 100644
--- a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/AbstractBuilder.java
+++ b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/AbstractBuilder.java
@@ -10,7 +10,7 @@
 import org.antlr.v4.runtime.misc.Interval;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.TerminalNode;
-import org.elasticsearch.xpack.ql.expression.Expression;
+import org.elasticsearch.xpack.ql.plan.logical.LogicalPlan;
 import org.elasticsearch.xpack.ql.tree.Location;
 import org.elasticsearch.xpack.ql.tree.Source;
 import org.elasticsearch.xpack.ql.util.Check;
@@ -25,6 +25,8 @@
  */
 abstract class AbstractBuilder extends EqlBaseBaseVisitor<Object> {
 
+    private static final Pattern slashPattern = Pattern.compile("\\\\.");
+
     @Override
     public Object visit(ParseTree tree) {
         Object result = super.visit(tree);
@@ -44,12 +46,12 @@ protected <T> T typedParsing(ParseTree ctx, Class<T> type) {
                         type.getSimpleName(), (result != null ? result.getClass().getSimpleName() : "null"));
     }
 
-    protected Expression expression(ParseTree ctx) {
-        return typedParsing(ctx, Expression.class);
+    protected LogicalPlan plan(ParseTree ctx) {
+        return typedParsing(ctx, LogicalPlan.class);
     }
 
-    protected List<Expression> expressions(List<? extends ParserRuleContext> ctxs) {
-        return visitList(ctxs, Expression.class);
+    protected List<LogicalPlan> plans(List<? extends ParserRuleContext> ctxs) {
+        return visitList(ctxs, LogicalPlan.class);
     }
 
     protected <T> List<T> visitList(List<? extends ParserRuleContext> contexts, Class<T> clazz) {
@@ -113,14 +115,7 @@ static String text(ParseTree node) {
         return node == null ? null : node.getText();
     }
 
-    /**
-     * Extracts the actual unescaped string (literal) value of a terminal node.
-     */
-    static String string(TerminalNode node) {
-        return node == null ? null : unquoteString(node.getText());
-    }
-
-    static String unquoteString(String text) {
+    public static String unquoteString(String text) {
         // remove leading and trailing ' for strings and also eliminate escaped single quotes
         if (text == null) {
             return null;
@@ -132,9 +127,8 @@ static String unquoteString(String text) {
         }
 
         text = text.substring(1, text.length() - 1);
-        Pattern regex = Pattern.compile("\\\\.");
         StringBuffer resultString = new StringBuffer();
-        Matcher regexMatcher = regex.matcher(text);
+        Matcher regexMatcher = slashPattern.matcher(text);
 
         while (regexMatcher.find()) {
             String source = regexMatcher.group();
@@ -167,6 +161,7 @@ static String unquoteString(String text) {
                     replacement = "\\\\";
                     break;
                 default:
+                    // unknown escape sequence, pass through as-is
                     replacement = source;
             }
 
@@ -183,4 +178,5 @@ public Object visitTerminal(TerminalNode node) {
         Source source = source(node);
         throw new ParsingException(source, "Does not know how to handle {}", source.text());
     }
+
 }
diff --git a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/AstBuilder.java b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/AstBuilder.java
index 95f6e8dac3545..9867f757c5e2e 100644
--- a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/AstBuilder.java
+++ b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/AstBuilder.java
@@ -7,11 +7,12 @@
 package org.elasticsearch.xpack.eql.parser;
 
 import org.elasticsearch.xpack.eql.parser.EqlBaseParser.SingleStatementContext;
+import org.elasticsearch.xpack.ql.plan.logical.LogicalPlan;
 
-public class AstBuilder extends ExpressionBuilder {
+public class AstBuilder extends LogicalPlanBuilder {
 
     @Override
-    public Object visitSingleStatement(SingleStatementContext ctx) {
-        return expression(ctx.statement());
+    public LogicalPlan visitSingleStatement(SingleStatementContext ctx) {
+        return plan(ctx.statement());
     }
-}
\ No newline at end of file
+}
diff --git a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseBaseListener.java b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseBaseListener.java
index 1290235e7a40a..5c720fb6e4b0b 100644
--- a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseBaseListener.java
+++ b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseBaseListener.java
@@ -232,73 +232,61 @@ class EqlBaseBaseListener implements EqlBaseListener {
    *
    * <p>The default implementation does nothing.</p>
    */
-  @Override public void enterPredicated(EqlBaseParser.PredicatedContext ctx) { }
-  /**
-   * {@inheritDoc}
-   *
-   * <p>The default implementation does nothing.</p>
-   */
-  @Override public void exitPredicated(EqlBaseParser.PredicatedContext ctx) { }
-  /**
-   * {@inheritDoc}
-   *
-   * <p>The default implementation does nothing.</p>
-   */
-  @Override public void enterPredicate(EqlBaseParser.PredicateContext ctx) { }
+  @Override public void enterValueExpressionDefault(EqlBaseParser.ValueExpressionDefaultContext ctx) { }
   /**
    * {@inheritDoc}
    *
    * <p>The default implementation does nothing.</p>
    */
-  @Override public void exitPredicate(EqlBaseParser.PredicateContext ctx) { }
+  @Override public void exitValueExpressionDefault(EqlBaseParser.ValueExpressionDefaultContext ctx) { }
   /**
    * {@inheritDoc}
    *
    * <p>The default implementation does nothing.</p>
    */
-  @Override public void enterValueExpressionDefault(EqlBaseParser.ValueExpressionDefaultContext ctx) { }
+  @Override public void enterComparison(EqlBaseParser.ComparisonContext ctx) { }
   /**
    * {@inheritDoc}
    *
    * <p>The default implementation does nothing.</p>
    */
-  @Override public void exitValueExpressionDefault(EqlBaseParser.ValueExpressionDefaultContext ctx) { }
+  @Override public void exitComparison(EqlBaseParser.ComparisonContext ctx) { }
   /**
    * {@inheritDoc}
    *
    * <p>The default implementation does nothing.</p>
    */
-  @Override public void enterComparison(EqlBaseParser.ComparisonContext ctx) { }
+  @Override public void enterArithmeticBinary(EqlBaseParser.ArithmeticBinaryContext ctx) { }
   /**
    * {@inheritDoc}
    *
    * <p>The default implementation does nothing.</p>
    */
-  @Override public void exitComparison(EqlBaseParser.ComparisonContext ctx) { }
+  @Override public void exitArithmeticBinary(EqlBaseParser.ArithmeticBinaryContext ctx) { }
   /**
    * {@inheritDoc}
    *
    * <p>The default implementation does nothing.</p>
    */
-  @Override public void enterArithmeticBinary(EqlBaseParser.ArithmeticBinaryContext ctx) { }
+  @Override public void enterArithmeticUnary(EqlBaseParser.ArithmeticUnaryContext ctx) { }
   /**
    * {@inheritDoc}
    *
    * <p>The default implementation does nothing.</p>
    */
-  @Override public void exitArithmeticBinary(EqlBaseParser.ArithmeticBinaryContext ctx) { }
+  @Override public void exitArithmeticUnary(EqlBaseParser.ArithmeticUnaryContext ctx) { }
   /**
    * {@inheritDoc}
    *
    * <p>The default implementation does nothing.</p>
    */
-  @Override public void enterArithmeticUnary(EqlBaseParser.ArithmeticUnaryContext ctx) { }
+  @Override public void enterPredicate(EqlBaseParser.PredicateContext ctx) { }
   /**
    * {@inheritDoc}
    *
    * <p>The default implementation does nothing.</p>
    */
-  @Override public void exitArithmeticUnary(EqlBaseParser.ArithmeticUnaryContext ctx) { }
+  @Override public void exitPredicate(EqlBaseParser.PredicateContext ctx) { }
   /**
    * {@inheritDoc}
    *
diff --git a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseBaseVisitor.java b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseBaseVisitor.java
index cd981a4baf101..4f60c45ff5b71 100644
--- a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseBaseVisitor.java
+++ b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseBaseVisitor.java
@@ -143,42 +143,35 @@ class EqlBaseBaseVisitor<T> extends AbstractParseTreeVisitor<T> implements EqlBa
    * <p>The default implementation returns the result of calling
    * {@link #visitChildren} on {@code ctx}.</p>
    */
-  @Override public T visitPredicated(EqlBaseParser.PredicatedContext ctx) { return visitChildren(ctx); }
-  /**
-   * {@inheritDoc}
-   *
-   * <p>The default implementation returns the result of calling
-   * {@link #visitChildren} on {@code ctx}.</p>
-   */
-  @Override public T visitPredicate(EqlBaseParser.PredicateContext ctx) { return visitChildren(ctx); }
+  @Override public T visitValueExpressionDefault(EqlBaseParser.ValueExpressionDefaultContext ctx) { return visitChildren(ctx); }
   /**
    * {@inheritDoc}
    *
    * <p>The default implementation returns the result of calling
    * {@link #visitChildren} on {@code ctx}.</p>
    */
-  @Override public T visitValueExpressionDefault(EqlBaseParser.ValueExpressionDefaultContext ctx) { return visitChildren(ctx); }
+  @Override public T visitComparison(EqlBaseParser.ComparisonContext ctx) { return visitChildren(ctx); }
   /**
    * {@inheritDoc}
    *
    * <p>The default implementation returns the result of calling
    * {@link #visitChildren} on {@code ctx}.</p>
    */
-  @Override public T visitComparison(EqlBaseParser.ComparisonContext ctx) { return visitChildren(ctx); }
+  @Override public T visitArithmeticBinary(EqlBaseParser.ArithmeticBinaryContext ctx) { return visitChildren(ctx); }
   /**
    * {@inheritDoc}
    *
    * <p>The default implementation returns the result of calling
    * {@link #visitChildren} on {@code ctx}.</p>
    */
-  @Override public T visitArithmeticBinary(EqlBaseParser.ArithmeticBinaryContext ctx) { return visitChildren(ctx); }
+  @Override public T visitArithmeticUnary(EqlBaseParser.ArithmeticUnaryContext ctx) { return visitChildren(ctx); }
   /**
    * {@inheritDoc}
    *
    * <p>The default implementation returns the result of calling
    * {@link #visitChildren} on {@code ctx}.</p>
    */
-  @Override public T visitArithmeticUnary(EqlBaseParser.ArithmeticUnaryContext ctx) { return visitChildren(ctx); }
+  @Override public T visitPredicate(EqlBaseParser.PredicateContext ctx) { return visitChildren(ctx); }
   /**
    * {@inheritDoc}
    *
diff --git a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseListener.java b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseListener.java
index 43cd93d136c44..61e50f121c72c 100644
--- a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseListener.java
+++ b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseListener.java
@@ -195,26 +195,6 @@ interface EqlBaseListener extends ParseTreeListener {
    * @param ctx the parse tree
    */
   void exitLogicalBinary(EqlBaseParser.LogicalBinaryContext ctx);
-  /**
-   * Enter a parse tree produced by {@link EqlBaseParser#predicated}.
-   * @param ctx the parse tree
-   */
-  void enterPredicated(EqlBaseParser.PredicatedContext ctx);
-  /**
-   * Exit a parse tree produced by {@link EqlBaseParser#predicated}.
-   * @param ctx the parse tree
-   */
-  void exitPredicated(EqlBaseParser.PredicatedContext ctx);
-  /**
-   * Enter a parse tree produced by {@link EqlBaseParser#predicate}.
-   * @param ctx the parse tree
-   */
-  void enterPredicate(EqlBaseParser.PredicateContext ctx);
-  /**
-   * Exit a parse tree produced by {@link EqlBaseParser#predicate}.
-   * @param ctx the parse tree
-   */
-  void exitPredicate(EqlBaseParser.PredicateContext ctx);
   /**
    * Enter a parse tree produced by the {@code valueExpressionDefault}
    * labeled alternative in {@link EqlBaseParser#valueExpression}.
@@ -263,6 +243,16 @@ interface EqlBaseListener extends ParseTreeListener {
    * @param ctx the parse tree
    */
   void exitArithmeticUnary(EqlBaseParser.ArithmeticUnaryContext ctx);
+  /**
+   * Enter a parse tree produced by {@link EqlBaseParser#predicate}.
+   * @param ctx the parse tree
+   */
+  void enterPredicate(EqlBaseParser.PredicateContext ctx);
+  /**
+   * Exit a parse tree produced by {@link EqlBaseParser#predicate}.
+   * @param ctx the parse tree
+   */
+  void exitPredicate(EqlBaseParser.PredicateContext ctx);
   /**
    * Enter a parse tree produced by the {@code constantDefault}
    * labeled alternative in {@link EqlBaseParser#primaryExpression}.
diff --git a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseParser.java b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseParser.java
index 1bed5e7169e92..a19f7dcdb50be 100644
--- a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseParser.java
+++ b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseParser.java
@@ -28,17 +28,16 @@ class EqlBaseParser extends Parser {
     RULE_query = 3, RULE_sequenceParams = 4, RULE_sequence = 5, RULE_join = 6, 
     RULE_pipe = 7, RULE_joinKeys = 8, RULE_joinTerm = 9, RULE_sequenceTerm = 10, 
     RULE_subquery = 11, RULE_eventQuery = 12, RULE_expression = 13, RULE_booleanExpression = 14, 
-    RULE_predicated = 15, RULE_predicate = 16, RULE_valueExpression = 17, 
-    RULE_primaryExpression = 18, RULE_functionExpression = 19, RULE_constant = 20, 
-    RULE_comparisonOperator = 21, RULE_booleanValue = 22, RULE_qualifiedName = 23, 
-    RULE_identifier = 24, RULE_timeUnit = 25, RULE_number = 26, RULE_string = 27;
+    RULE_valueExpression = 15, RULE_predicate = 16, RULE_primaryExpression = 17, 
+    RULE_functionExpression = 18, RULE_constant = 19, RULE_comparisonOperator = 20, 
+    RULE_booleanValue = 21, RULE_qualifiedName = 22, RULE_identifier = 23, 
+    RULE_timeUnit = 24, RULE_number = 25, RULE_string = 26;
   public static final String[] ruleNames = {
     "singleStatement", "singleExpression", "statement", "query", "sequenceParams", 
     "sequence", "join", "pipe", "joinKeys", "joinTerm", "sequenceTerm", "subquery", 
-    "eventQuery", "expression", "booleanExpression", "predicated", "predicate", 
-    "valueExpression", "primaryExpression", "functionExpression", "constant", 
-    "comparisonOperator", "booleanValue", "qualifiedName", "identifier", "timeUnit", 
-    "number", "string"
+    "eventQuery", "expression", "booleanExpression", "valueExpression", "predicate", 
+    "primaryExpression", "functionExpression", "constant", "comparisonOperator", 
+    "booleanValue", "qualifiedName", "identifier", "timeUnit", "number", "string"
   };
 
   private static final String[] _LITERAL_NAMES = {
@@ -135,9 +134,9 @@ public final SingleStatementContext singleStatement() throws RecognitionExceptio
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(56);
+      setState(54);
       statement();
-      setState(57);
+      setState(55);
       match(EOF);
       }
     }
@@ -182,9 +181,9 @@ public final SingleExpressionContext singleExpression() throws RecognitionExcept
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(59);
+      setState(57);
       expression();
-      setState(60);
+      setState(58);
       match(EOF);
       }
     }
@@ -235,19 +234,19 @@ public final StatementContext statement() throws RecognitionException {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(62);
+      setState(60);
       query();
-      setState(66);
+      setState(64);
       _errHandler.sync(this);
       _la = _input.LA(1);
       while (_la==PIPE) {
         {
         {
-        setState(63);
+        setState(61);
         pipe();
         }
         }
-        setState(68);
+        setState(66);
         _errHandler.sync(this);
         _la = _input.LA(1);
       }
@@ -297,19 +296,19 @@ public final QueryContext query() throws RecognitionException {
     QueryContext _localctx = new QueryContext(_ctx, getState());
     enterRule(_localctx, 6, RULE_query);
     try {
-      setState(72);
+      setState(70);
       switch (_input.LA(1)) {
       case SEQUENCE:
         enterOuterAlt(_localctx, 1);
         {
-        setState(69);
+        setState(67);
         sequence();
         }
         break;
       case JOIN:
         enterOuterAlt(_localctx, 2);
         {
-        setState(70);
+        setState(68);
         join();
         }
         break;
@@ -317,7 +316,7 @@ public final QueryContext query() throws RecognitionException {
       case IDENTIFIER:
         enterOuterAlt(_localctx, 3);
         {
-        setState(71);
+        setState(69);
         eventQuery();
         }
         break;
@@ -368,14 +367,14 @@ public final SequenceParamsContext sequenceParams() throws RecognitionException
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(74);
+      setState(72);
       match(WITH);
       {
-      setState(75);
+      setState(73);
       match(MAXSPAN);
-      setState(76);
+      setState(74);
       match(EQ);
-      setState(77);
+      setState(75);
       timeUnit();
       }
       }
@@ -433,19 +432,19 @@ public final SequenceContext sequence() throws RecognitionException {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(79);
+      setState(77);
       match(SEQUENCE);
-      setState(88);
+      setState(86);
       switch (_input.LA(1)) {
       case BY:
         {
-        setState(80);
+        setState(78);
         ((SequenceContext)_localctx).by = joinKeys();
-        setState(82);
+        setState(80);
         _la = _input.LA(1);
         if (_la==WITH) {
           {
-          setState(81);
+          setState(79);
           sequenceParams();
           }
         }
@@ -454,13 +453,13 @@ public final SequenceContext sequence() throws RecognitionException {
         break;
       case WITH:
         {
-        setState(84);
+        setState(82);
         sequenceParams();
-        setState(86);
+        setState(84);
         _la = _input.LA(1);
         if (_la==BY) {
           {
-          setState(85);
+          setState(83);
           ((SequenceContext)_localctx).by = joinKeys();
           }
         }
@@ -472,29 +471,29 @@ public final SequenceContext sequence() throws RecognitionException {
       default:
         throw new NoViableAltException(this);
       }
-      setState(90);
+      setState(88);
       sequenceTerm();
-      setState(92); 
+      setState(90); 
       _errHandler.sync(this);
       _la = _input.LA(1);
       do {
         {
         {
-        setState(91);
+        setState(89);
         sequenceTerm();
         }
         }
-        setState(94); 
+        setState(92); 
         _errHandler.sync(this);
         _la = _input.LA(1);
       } while ( _la==LB );
-      setState(98);
+      setState(96);
       _la = _input.LA(1);
       if (_la==UNTIL) {
         {
-        setState(96);
+        setState(94);
         match(UNTIL);
-        setState(97);
+        setState(95);
         sequenceTerm();
         }
       }
@@ -551,40 +550,40 @@ public final JoinContext join() throws RecognitionException {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(100);
+      setState(98);
       match(JOIN);
-      setState(102);
+      setState(100);
       _la = _input.LA(1);
       if (_la==BY) {
         {
-        setState(101);
+        setState(99);
         ((JoinContext)_localctx).by = joinKeys();
         }
       }
 
-      setState(104);
+      setState(102);
       joinTerm();
-      setState(106); 
+      setState(104); 
       _errHandler.sync(this);
       _la = _input.LA(1);
       do {
         {
         {
-        setState(105);
+        setState(103);
         joinTerm();
         }
         }
-        setState(108); 
+        setState(106); 
         _errHandler.sync(this);
         _la = _input.LA(1);
       } while ( _la==LB );
-      setState(112);
+      setState(110);
       _la = _input.LA(1);
       if (_la==UNTIL) {
         {
-        setState(110);
+        setState(108);
         match(UNTIL);
-        setState(111);
+        setState(109);
         joinTerm();
         }
       }
@@ -642,29 +641,29 @@ public final PipeContext pipe() throws RecognitionException {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(114);
+      setState(112);
       match(PIPE);
-      setState(115);
+      setState(113);
       ((PipeContext)_localctx).kind = match(IDENTIFIER);
-      setState(124);
+      setState(122);
       _la = _input.LA(1);
       if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FALSE) | (1L << NOT) | (1L << NULL) | (1L << TRUE) | (1L << PLUS) | (1L << MINUS) | (1L << LP) | (1L << ESCAPED_IDENTIFIER) | (1L << STRING) | (1L << INTEGER_VALUE) | (1L << DECIMAL_VALUE) | (1L << IDENTIFIER))) != 0)) {
         {
-        setState(116);
+        setState(114);
         booleanExpression(0);
-        setState(121);
+        setState(119);
         _errHandler.sync(this);
         _la = _input.LA(1);
         while (_la==COMMA) {
           {
           {
-          setState(117);
+          setState(115);
           match(COMMA);
-          setState(118);
+          setState(116);
           booleanExpression(0);
           }
           }
-          setState(123);
+          setState(121);
           _errHandler.sync(this);
           _la = _input.LA(1);
         }
@@ -722,23 +721,23 @@ public final JoinKeysContext joinKeys() throws RecognitionException {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(126);
+      setState(124);
       match(BY);
-      setState(127);
+      setState(125);
       expression();
-      setState(132);
+      setState(130);
       _errHandler.sync(this);
       _la = _input.LA(1);
       while (_la==COMMA) {
         {
         {
-        setState(128);
+        setState(126);
         match(COMMA);
-        setState(129);
+        setState(127);
         expression();
         }
         }
-        setState(134);
+        setState(132);
         _errHandler.sync(this);
         _la = _input.LA(1);
       }
@@ -789,13 +788,13 @@ public final JoinTermContext joinTerm() throws RecognitionException {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(135);
+      setState(133);
       subquery();
-      setState(137);
+      setState(135);
       _la = _input.LA(1);
       if (_la==BY) {
         {
-        setState(136);
+        setState(134);
         ((JoinTermContext)_localctx).by = joinKeys();
         }
       }
@@ -852,21 +851,21 @@ public final SequenceTermContext sequenceTerm() throws RecognitionException {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(139);
+      setState(137);
       subquery();
-      setState(145);
+      setState(143);
       _la = _input.LA(1);
       if (_la==FORK) {
         {
-        setState(140);
+        setState(138);
         match(FORK);
-        setState(143);
+        setState(141);
         _la = _input.LA(1);
         if (_la==EQ) {
           {
-          setState(141);
+          setState(139);
           match(EQ);
-          setState(142);
+          setState(140);
           booleanValue();
           }
         }
@@ -874,11 +873,11 @@ public final SequenceTermContext sequenceTerm() throws RecognitionException {
         }
       }
 
-      setState(148);
+      setState(146);
       _la = _input.LA(1);
       if (_la==BY) {
         {
-        setState(147);
+        setState(145);
         ((SequenceTermContext)_localctx).by = joinKeys();
         }
       }
@@ -927,11 +926,11 @@ public final SubqueryContext subquery() throws RecognitionException {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(150);
+      setState(148);
       match(LB);
-      setState(151);
+      setState(149);
       eventQuery();
-      setState(152);
+      setState(150);
       match(RB);
       }
     }
@@ -980,11 +979,11 @@ public final EventQueryContext eventQuery() throws RecognitionException {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(154);
+      setState(152);
       ((EventQueryContext)_localctx).event = identifier();
-      setState(155);
+      setState(153);
       match(WHERE);
-      setState(156);
+      setState(154);
       expression();
       }
     }
@@ -1028,7 +1027,7 @@ public final ExpressionContext expression() throws RecognitionException {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(158);
+      setState(156);
       booleanExpression(0);
       }
     }
@@ -1075,8 +1074,8 @@ public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
     }
   }
   public static class BooleanDefaultContext extends BooleanExpressionContext {
-    public PredicatedContext predicated() {
-      return getRuleContext(PredicatedContext.class,0);
+    public ValueExpressionContext valueExpression() {
+      return getRuleContext(ValueExpressionContext.class,0);
     }
     public BooleanDefaultContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
     @Override
@@ -1158,7 +1157,7 @@ private BooleanExpressionContext booleanExpression(int _p) throws RecognitionExc
       int _alt;
       enterOuterAlt(_localctx, 1);
       {
-      setState(167);
+      setState(165);
       _errHandler.sync(this);
       switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
       case 1:
@@ -1167,9 +1166,9 @@ private BooleanExpressionContext booleanExpression(int _p) throws RecognitionExc
         _ctx = _localctx;
         _prevctx = _localctx;
 
-        setState(161);
+        setState(159);
         match(NOT);
-        setState(162);
+        setState(160);
         booleanExpression(5);
         }
         break;
@@ -1178,11 +1177,11 @@ private BooleanExpressionContext booleanExpression(int _p) throws RecognitionExc
         _localctx = new ProcessCheckContext(_localctx);
         _ctx = _localctx;
         _prevctx = _localctx;
-        setState(163);
+        setState(161);
         ((ProcessCheckContext)_localctx).relationship = match(IDENTIFIER);
-        setState(164);
+        setState(162);
         match(OF);
-        setState(165);
+        setState(163);
         subquery();
         }
         break;
@@ -1191,13 +1190,13 @@ private BooleanExpressionContext booleanExpression(int _p) throws RecognitionExc
         _localctx = new BooleanDefaultContext(_localctx);
         _ctx = _localctx;
         _prevctx = _localctx;
-        setState(166);
-        predicated();
+        setState(164);
+        valueExpression(0);
         }
         break;
       }
       _ctx.stop = _input.LT(-1);
-      setState(177);
+      setState(175);
       _errHandler.sync(this);
       _alt = getInterpreter().adaptivePredict(_input,19,_ctx);
       while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
@@ -1205,7 +1204,7 @@ private BooleanExpressionContext booleanExpression(int _p) throws RecognitionExc
           if ( _parseListeners!=null ) triggerExitRuleEvent();
           _prevctx = _localctx;
           {
-          setState(175);
+          setState(173);
           _errHandler.sync(this);
           switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
           case 1:
@@ -1213,11 +1212,11 @@ private BooleanExpressionContext booleanExpression(int _p) throws RecognitionExc
             _localctx = new LogicalBinaryContext(new BooleanExpressionContext(_parentctx, _parentState));
             ((LogicalBinaryContext)_localctx).left = _prevctx;
             pushNewRecursionContext(_localctx, _startState, RULE_booleanExpression);
-            setState(169);
+            setState(167);
             if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
-            setState(170);
+            setState(168);
             ((LogicalBinaryContext)_localctx).operator = match(AND);
-            setState(171);
+            setState(169);
             ((LogicalBinaryContext)_localctx).right = booleanExpression(3);
             }
             break;
@@ -1226,18 +1225,18 @@ private BooleanExpressionContext booleanExpression(int _p) throws RecognitionExc
             _localctx = new LogicalBinaryContext(new BooleanExpressionContext(_parentctx, _parentState));
             ((LogicalBinaryContext)_localctx).left = _prevctx;
             pushNewRecursionContext(_localctx, _startState, RULE_booleanExpression);
-            setState(172);
+            setState(170);
             if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
-            setState(173);
+            setState(171);
             ((LogicalBinaryContext)_localctx).operator = match(OR);
-            setState(174);
+            setState(172);
             ((LogicalBinaryContext)_localctx).right = booleanExpression(2);
             }
             break;
           }
           } 
         }
-        setState(179);
+        setState(177);
         _errHandler.sync(this);
         _alt = getInterpreter().adaptivePredict(_input,19,_ctx);
       }
@@ -1254,151 +1253,6 @@ private BooleanExpressionContext booleanExpression(int _p) throws RecognitionExc
     return _localctx;
   }
 
-  public static class PredicatedContext extends ParserRuleContext {
-    public ValueExpressionContext valueExpression() {
-      return getRuleContext(ValueExpressionContext.class,0);
-    }
-    public PredicateContext predicate() {
-      return getRuleContext(PredicateContext.class,0);
-    }
-    public PredicatedContext(ParserRuleContext parent, int invokingState) {
-      super(parent, invokingState);
-    }
-    @Override public int getRuleIndex() { return RULE_predicated; }
-    @Override
-    public void enterRule(ParseTreeListener listener) {
-      if ( listener instanceof EqlBaseListener ) ((EqlBaseListener)listener).enterPredicated(this);
-    }
-    @Override
-    public void exitRule(ParseTreeListener listener) {
-      if ( listener instanceof EqlBaseListener ) ((EqlBaseListener)listener).exitPredicated(this);
-    }
-    @Override
-    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
-      if ( visitor instanceof EqlBaseVisitor ) return ((EqlBaseVisitor<? extends T>)visitor).visitPredicated(this);
-      else return visitor.visitChildren(this);
-    }
-  }
-
-  public final PredicatedContext predicated() throws RecognitionException {
-    PredicatedContext _localctx = new PredicatedContext(_ctx, getState());
-    enterRule(_localctx, 30, RULE_predicated);
-    try {
-      enterOuterAlt(_localctx, 1);
-      {
-      setState(180);
-      valueExpression(0);
-      setState(182);
-      _errHandler.sync(this);
-      switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
-      case 1:
-        {
-        setState(181);
-        predicate();
-        }
-        break;
-      }
-      }
-    }
-    catch (RecognitionException re) {
-      _localctx.exception = re;
-      _errHandler.reportError(this, re);
-      _errHandler.recover(this, re);
-    }
-    finally {
-      exitRule();
-    }
-    return _localctx;
-  }
-
-  public static class PredicateContext extends ParserRuleContext {
-    public Token kind;
-    public TerminalNode LP() { return getToken(EqlBaseParser.LP, 0); }
-    public List<ValueExpressionContext> valueExpression() {
-      return getRuleContexts(ValueExpressionContext.class);
-    }
-    public ValueExpressionContext valueExpression(int i) {
-      return getRuleContext(ValueExpressionContext.class,i);
-    }
-    public TerminalNode RP() { return getToken(EqlBaseParser.RP, 0); }
-    public TerminalNode IN() { return getToken(EqlBaseParser.IN, 0); }
-    public TerminalNode NOT() { return getToken(EqlBaseParser.NOT, 0); }
-    public List<TerminalNode> COMMA() { return getTokens(EqlBaseParser.COMMA); }
-    public TerminalNode COMMA(int i) {
-      return getToken(EqlBaseParser.COMMA, i);
-    }
-    public PredicateContext(ParserRuleContext parent, int invokingState) {
-      super(parent, invokingState);
-    }
-    @Override public int getRuleIndex() { return RULE_predicate; }
-    @Override
-    public void enterRule(ParseTreeListener listener) {
-      if ( listener instanceof EqlBaseListener ) ((EqlBaseListener)listener).enterPredicate(this);
-    }
-    @Override
-    public void exitRule(ParseTreeListener listener) {
-      if ( listener instanceof EqlBaseListener ) ((EqlBaseListener)listener).exitPredicate(this);
-    }
-    @Override
-    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
-      if ( visitor instanceof EqlBaseVisitor ) return ((EqlBaseVisitor<? extends T>)visitor).visitPredicate(this);
-      else return visitor.visitChildren(this);
-    }
-  }
-
-  public final PredicateContext predicate() throws RecognitionException {
-    PredicateContext _localctx = new PredicateContext(_ctx, getState());
-    enterRule(_localctx, 32, RULE_predicate);
-    int _la;
-    try {
-      enterOuterAlt(_localctx, 1);
-      {
-      setState(185);
-      _la = _input.LA(1);
-      if (_la==NOT) {
-        {
-        setState(184);
-        match(NOT);
-        }
-      }
-
-      setState(187);
-      ((PredicateContext)_localctx).kind = match(IN);
-      setState(188);
-      match(LP);
-      setState(189);
-      valueExpression(0);
-      setState(194);
-      _errHandler.sync(this);
-      _la = _input.LA(1);
-      while (_la==COMMA) {
-        {
-        {
-        setState(190);
-        match(COMMA);
-        setState(191);
-        valueExpression(0);
-        }
-        }
-        setState(196);
-        _errHandler.sync(this);
-        _la = _input.LA(1);
-      }
-      setState(197);
-      match(RP);
-      }
-    }
-    catch (RecognitionException re) {
-      _localctx.exception = re;
-      _errHandler.reportError(this, re);
-      _errHandler.recover(this, re);
-    }
-    finally {
-      exitRule();
-    }
-    return _localctx;
-  }
-
   public static class ValueExpressionContext extends ParserRuleContext {
     public ValueExpressionContext(ParserRuleContext parent, int invokingState) {
       super(parent, invokingState);
@@ -1414,6 +1268,9 @@ public static class ValueExpressionDefaultContext extends ValueExpressionContext
     public PrimaryExpressionContext primaryExpression() {
       return getRuleContext(PrimaryExpressionContext.class,0);
     }
+    public PredicateContext predicate() {
+      return getRuleContext(PredicateContext.class,0);
+    }
     public ValueExpressionDefaultContext(ValueExpressionContext ctx) { copyFrom(ctx); }
     @Override
     public void enterRule(ParseTreeListener listener) {
@@ -1518,14 +1375,14 @@ private ValueExpressionContext valueExpression(int _p) throws RecognitionExcepti
     int _parentState = getState();
     ValueExpressionContext _localctx = new ValueExpressionContext(_ctx, _parentState);
     ValueExpressionContext _prevctx = _localctx;
-    int _startState = 34;
-    enterRecursionRule(_localctx, 34, RULE_valueExpression, _p);
+    int _startState = 30;
+    enterRecursionRule(_localctx, 30, RULE_valueExpression, _p);
     int _la;
     try {
       int _alt;
       enterOuterAlt(_localctx, 1);
       {
-      setState(203);
+      setState(185);
       switch (_input.LA(1)) {
       case FALSE:
       case NULL:
@@ -1541,8 +1398,18 @@ private ValueExpressionContext valueExpression(int _p) throws RecognitionExcepti
         _ctx = _localctx;
         _prevctx = _localctx;
 
-        setState(200);
+        setState(179);
         primaryExpression();
+        setState(181);
+        _errHandler.sync(this);
+        switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
+        case 1:
+          {
+          setState(180);
+          predicate();
+          }
+          break;
+        }
         }
         break;
       case PLUS:
@@ -1551,7 +1418,7 @@ private ValueExpressionContext valueExpression(int _p) throws RecognitionExcepti
         _localctx = new ArithmeticUnaryContext(_localctx);
         _ctx = _localctx;
         _prevctx = _localctx;
-        setState(201);
+        setState(183);
         ((ArithmeticUnaryContext)_localctx).operator = _input.LT(1);
         _la = _input.LA(1);
         if ( !(_la==PLUS || _la==MINUS) ) {
@@ -1559,7 +1426,7 @@ private ValueExpressionContext valueExpression(int _p) throws RecognitionExcepti
         } else {
           consume();
         }
-        setState(202);
+        setState(184);
         valueExpression(4);
         }
         break;
@@ -1567,25 +1434,25 @@ private ValueExpressionContext valueExpression(int _p) throws RecognitionExcepti
         throw new NoViableAltException(this);
       }
       _ctx.stop = _input.LT(-1);
-      setState(217);
+      setState(199);
       _errHandler.sync(this);
-      _alt = getInterpreter().adaptivePredict(_input,25,_ctx);
+      _alt = getInterpreter().adaptivePredict(_input,23,_ctx);
       while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
         if ( _alt==1 ) {
           if ( _parseListeners!=null ) triggerExitRuleEvent();
           _prevctx = _localctx;
           {
-          setState(215);
+          setState(197);
           _errHandler.sync(this);
-          switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
+          switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
           case 1:
             {
             _localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState));
             ((ArithmeticBinaryContext)_localctx).left = _prevctx;
             pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
-            setState(205);
+            setState(187);
             if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
-            setState(206);
+            setState(188);
             ((ArithmeticBinaryContext)_localctx).operator = _input.LT(1);
             _la = _input.LA(1);
             if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ASTERISK) | (1L << SLASH) | (1L << PERCENT))) != 0)) ) {
@@ -1593,7 +1460,7 @@ private ValueExpressionContext valueExpression(int _p) throws RecognitionExcepti
             } else {
               consume();
             }
-            setState(207);
+            setState(189);
             ((ArithmeticBinaryContext)_localctx).right = valueExpression(4);
             }
             break;
@@ -1602,9 +1469,9 @@ private ValueExpressionContext valueExpression(int _p) throws RecognitionExcepti
             _localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState));
             ((ArithmeticBinaryContext)_localctx).left = _prevctx;
             pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
-            setState(208);
+            setState(190);
             if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
-            setState(209);
+            setState(191);
             ((ArithmeticBinaryContext)_localctx).operator = _input.LT(1);
             _la = _input.LA(1);
             if ( !(_la==PLUS || _la==MINUS) ) {
@@ -1612,7 +1479,7 @@ private ValueExpressionContext valueExpression(int _p) throws RecognitionExcepti
             } else {
               consume();
             }
-            setState(210);
+            setState(192);
             ((ArithmeticBinaryContext)_localctx).right = valueExpression(3);
             }
             break;
@@ -1621,20 +1488,20 @@ private ValueExpressionContext valueExpression(int _p) throws RecognitionExcepti
             _localctx = new ComparisonContext(new ValueExpressionContext(_parentctx, _parentState));
             ((ComparisonContext)_localctx).left = _prevctx;
             pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
-            setState(211);
+            setState(193);
             if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
-            setState(212);
+            setState(194);
             comparisonOperator();
-            setState(213);
+            setState(195);
             ((ComparisonContext)_localctx).right = valueExpression(2);
             }
             break;
           }
           } 
         }
-        setState(219);
+        setState(201);
         _errHandler.sync(this);
-        _alt = getInterpreter().adaptivePredict(_input,25,_ctx);
+        _alt = getInterpreter().adaptivePredict(_input,23,_ctx);
       }
       }
     }
@@ -1649,6 +1516,94 @@ private ValueExpressionContext valueExpression(int _p) throws RecognitionExcepti
     return _localctx;
   }
 
+  public static class PredicateContext extends ParserRuleContext {
+    public Token kind;
+    public TerminalNode LP() { return getToken(EqlBaseParser.LP, 0); }
+    public List<ExpressionContext> expression() {
+      return getRuleContexts(ExpressionContext.class);
+    }
+    public ExpressionContext expression(int i) {
+      return getRuleContext(ExpressionContext.class,i);
+    }
+    public TerminalNode RP() { return getToken(EqlBaseParser.RP, 0); }
+    public TerminalNode IN() { return getToken(EqlBaseParser.IN, 0); }
+    public TerminalNode NOT() { return getToken(EqlBaseParser.NOT, 0); }
+    public List<TerminalNode> COMMA() { return getTokens(EqlBaseParser.COMMA); }
+    public TerminalNode COMMA(int i) {
+      return getToken(EqlBaseParser.COMMA, i);
+    }
+    public PredicateContext(ParserRuleContext parent, int invokingState) {
+      super(parent, invokingState);
+    }
+    @Override public int getRuleIndex() { return RULE_predicate; }
+    @Override
+    public void enterRule(ParseTreeListener listener) {
+      if ( listener instanceof EqlBaseListener ) ((EqlBaseListener)listener).enterPredicate(this);
+    }
+    @Override
+    public void exitRule(ParseTreeListener listener) {
+      if ( listener instanceof EqlBaseListener ) ((EqlBaseListener)listener).exitPredicate(this);
+    }
+    @Override
+    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+      if ( visitor instanceof EqlBaseVisitor ) return ((EqlBaseVisitor<? extends T>)visitor).visitPredicate(this);
+      else return visitor.visitChildren(this);
+    }
+  }
+
+  public final PredicateContext predicate() throws RecognitionException {
+    PredicateContext _localctx = new PredicateContext(_ctx, getState());
+    enterRule(_localctx, 32, RULE_predicate);
+    int _la;
+    try {
+      enterOuterAlt(_localctx, 1);
+      {
+      setState(203);
+      _la = _input.LA(1);
+      if (_la==NOT) {
+        {
+        setState(202);
+        match(NOT);
+        }
+      }
+
+      setState(205);
+      ((PredicateContext)_localctx).kind = match(IN);
+      setState(206);
+      match(LP);
+      setState(207);
+      expression();
+      setState(212);
+      _errHandler.sync(this);
+      _la = _input.LA(1);
+      while (_la==COMMA) {
+        {
+        {
+        setState(208);
+        match(COMMA);
+        setState(209);
+        expression();
+        }
+        }
+        setState(214);
+        _errHandler.sync(this);
+        _la = _input.LA(1);
+      }
+      setState(215);
+      match(RP);
+      }
+    }
+    catch (RecognitionException re) {
+      _localctx.exception = re;
+      _errHandler.reportError(this, re);
+      _errHandler.recover(this, re);
+    }
+    finally {
+      exitRule();
+    }
+    return _localctx;
+  }
+
   public static class PrimaryExpressionContext extends ParserRuleContext {
     public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) {
       super(parent, invokingState);
@@ -1741,16 +1696,16 @@ public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 
   public final PrimaryExpressionContext primaryExpression() throws RecognitionException {
     PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, getState());
-    enterRule(_localctx, 36, RULE_primaryExpression);
+    enterRule(_localctx, 34, RULE_primaryExpression);
     try {
-      setState(227);
+      setState(224);
       _errHandler.sync(this);
       switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
       case 1:
         _localctx = new ConstantDefaultContext(_localctx);
         enterOuterAlt(_localctx, 1);
         {
-        setState(220);
+        setState(217);
         constant();
         }
         break;
@@ -1758,7 +1713,7 @@ public final PrimaryExpressionContext primaryExpression() throws RecognitionExce
         _localctx = new FunctionContext(_localctx);
         enterOuterAlt(_localctx, 2);
         {
-        setState(221);
+        setState(218);
         functionExpression();
         }
         break;
@@ -1766,7 +1721,7 @@ public final PrimaryExpressionContext primaryExpression() throws RecognitionExce
         _localctx = new DereferenceContext(_localctx);
         enterOuterAlt(_localctx, 3);
         {
-        setState(222);
+        setState(219);
         qualifiedName();
         }
         break;
@@ -1774,11 +1729,11 @@ public final PrimaryExpressionContext primaryExpression() throws RecognitionExce
         _localctx = new ParenthesizedExpressionContext(_localctx);
         enterOuterAlt(_localctx, 4);
         {
-        setState(223);
+        setState(220);
         match(LP);
-        setState(224);
+        setState(221);
         expression();
-        setState(225);
+        setState(222);
         match(RP);
         }
         break;
@@ -1831,41 +1786,41 @@ public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 
   public final FunctionExpressionContext functionExpression() throws RecognitionException {
     FunctionExpressionContext _localctx = new FunctionExpressionContext(_ctx, getState());
-    enterRule(_localctx, 38, RULE_functionExpression);
+    enterRule(_localctx, 36, RULE_functionExpression);
     int _la;
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(229);
+      setState(226);
       ((FunctionExpressionContext)_localctx).name = match(IDENTIFIER);
-      setState(230);
+      setState(227);
       match(LP);
-      setState(239);
+      setState(236);
       _la = _input.LA(1);
       if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FALSE) | (1L << NOT) | (1L << NULL) | (1L << TRUE) | (1L << PLUS) | (1L << MINUS) | (1L << LP) | (1L << ESCAPED_IDENTIFIER) | (1L << STRING) | (1L << INTEGER_VALUE) | (1L << DECIMAL_VALUE) | (1L << IDENTIFIER))) != 0)) {
         {
-        setState(231);
+        setState(228);
         expression();
-        setState(236);
+        setState(233);
         _errHandler.sync(this);
         _la = _input.LA(1);
         while (_la==COMMA) {
           {
           {
-          setState(232);
+          setState(229);
           match(COMMA);
-          setState(233);
+          setState(230);
           expression();
           }
           }
-          setState(238);
+          setState(235);
           _errHandler.sync(this);
           _la = _input.LA(1);
         }
         }
       }
 
-      setState(241);
+      setState(238);
       match(RP);
       }
     }
@@ -1968,15 +1923,15 @@ public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 
   public final ConstantContext constant() throws RecognitionException {
     ConstantContext _localctx = new ConstantContext(_ctx, getState());
-    enterRule(_localctx, 40, RULE_constant);
+    enterRule(_localctx, 38, RULE_constant);
     try {
-      setState(247);
+      setState(244);
       switch (_input.LA(1)) {
       case NULL:
         _localctx = new NullLiteralContext(_localctx);
         enterOuterAlt(_localctx, 1);
         {
-        setState(243);
+        setState(240);
         match(NULL);
         }
         break;
@@ -1985,7 +1940,7 @@ public final ConstantContext constant() throws RecognitionException {
         _localctx = new NumericLiteralContext(_localctx);
         enterOuterAlt(_localctx, 2);
         {
-        setState(244);
+        setState(241);
         number();
         }
         break;
@@ -1994,7 +1949,7 @@ public final ConstantContext constant() throws RecognitionException {
         _localctx = new BooleanLiteralContext(_localctx);
         enterOuterAlt(_localctx, 3);
         {
-        setState(245);
+        setState(242);
         booleanValue();
         }
         break;
@@ -2002,7 +1957,7 @@ public final ConstantContext constant() throws RecognitionException {
         _localctx = new StringLiteralContext(_localctx);
         enterOuterAlt(_localctx, 4);
         {
-        setState(246);
+        setState(243);
         string();
         }
         break;
@@ -2049,12 +2004,12 @@ public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 
   public final ComparisonOperatorContext comparisonOperator() throws RecognitionException {
     ComparisonOperatorContext _localctx = new ComparisonOperatorContext(_ctx, getState());
-    enterRule(_localctx, 42, RULE_comparisonOperator);
+    enterRule(_localctx, 40, RULE_comparisonOperator);
     int _la;
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(249);
+      setState(246);
       _la = _input.LA(1);
       if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EQ) | (1L << NEQ) | (1L << LT) | (1L << LTE) | (1L << GT) | (1L << GTE))) != 0)) ) {
       _errHandler.recoverInline(this);
@@ -2098,12 +2053,12 @@ public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 
   public final BooleanValueContext booleanValue() throws RecognitionException {
     BooleanValueContext _localctx = new BooleanValueContext(_ctx, getState());
-    enterRule(_localctx, 44, RULE_booleanValue);
+    enterRule(_localctx, 42, RULE_booleanValue);
     int _la;
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(251);
+      setState(248);
       _la = _input.LA(1);
       if ( !(_la==FALSE || _la==TRUE) ) {
       _errHandler.recoverInline(this);
@@ -2167,49 +2122,49 @@ public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 
   public final QualifiedNameContext qualifiedName() throws RecognitionException {
     QualifiedNameContext _localctx = new QualifiedNameContext(_ctx, getState());
-    enterRule(_localctx, 46, RULE_qualifiedName);
+    enterRule(_localctx, 44, RULE_qualifiedName);
     int _la;
     try {
       int _alt;
       enterOuterAlt(_localctx, 1);
       {
-      setState(253);
+      setState(250);
       identifier();
-      setState(265);
+      setState(262);
       _errHandler.sync(this);
       _alt = getInterpreter().adaptivePredict(_input,32,_ctx);
       while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
         if ( _alt==1 ) {
           {
-          setState(263);
+          setState(260);
           switch (_input.LA(1)) {
           case DOT:
             {
-            setState(254);
+            setState(251);
             match(DOT);
-            setState(255);
+            setState(252);
             identifier();
             }
             break;
           case LB:
             {
-            setState(256);
+            setState(253);
             match(LB);
-            setState(258); 
+            setState(255); 
             _errHandler.sync(this);
             _la = _input.LA(1);
             do {
               {
               {
-              setState(257);
+              setState(254);
               match(INTEGER_VALUE);
               }
               }
-              setState(260); 
+              setState(257); 
               _errHandler.sync(this);
               _la = _input.LA(1);
             } while ( _la==INTEGER_VALUE );
-            setState(262);
+            setState(259);
             match(RB);
             }
             break;
@@ -2218,7 +2173,7 @@ public final QualifiedNameContext qualifiedName() throws RecognitionException {
           }
           } 
         }
-        setState(267);
+        setState(264);
         _errHandler.sync(this);
         _alt = getInterpreter().adaptivePredict(_input,32,_ctx);
       }
@@ -2259,12 +2214,12 @@ public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 
   public final IdentifierContext identifier() throws RecognitionException {
     IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
-    enterRule(_localctx, 48, RULE_identifier);
+    enterRule(_localctx, 46, RULE_identifier);
     int _la;
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(268);
+      setState(265);
       _la = _input.LA(1);
       if ( !(_la==ESCAPED_IDENTIFIER || _la==IDENTIFIER) ) {
       _errHandler.recoverInline(this);
@@ -2311,18 +2266,18 @@ public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 
   public final TimeUnitContext timeUnit() throws RecognitionException {
     TimeUnitContext _localctx = new TimeUnitContext(_ctx, getState());
-    enterRule(_localctx, 50, RULE_timeUnit);
+    enterRule(_localctx, 48, RULE_timeUnit);
     int _la;
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(270);
+      setState(267);
       number();
-      setState(272);
+      setState(269);
       _la = _input.LA(1);
       if (_la==IDENTIFIER) {
         {
-        setState(271);
+        setState(268);
         ((TimeUnitContext)_localctx).unit = match(IDENTIFIER);
         }
       }
@@ -2388,15 +2343,15 @@ public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 
   public final NumberContext number() throws RecognitionException {
     NumberContext _localctx = new NumberContext(_ctx, getState());
-    enterRule(_localctx, 52, RULE_number);
+    enterRule(_localctx, 50, RULE_number);
     try {
-      setState(276);
+      setState(273);
       switch (_input.LA(1)) {
       case DECIMAL_VALUE:
         _localctx = new DecimalLiteralContext(_localctx);
         enterOuterAlt(_localctx, 1);
         {
-        setState(274);
+        setState(271);
         match(DECIMAL_VALUE);
         }
         break;
@@ -2404,7 +2359,7 @@ public final NumberContext number() throws RecognitionException {
         _localctx = new IntegerLiteralContext(_localctx);
         enterOuterAlt(_localctx, 2);
         {
-        setState(275);
+        setState(272);
         match(INTEGER_VALUE);
         }
         break;
@@ -2446,11 +2401,11 @@ public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 
   public final StringContext string() throws RecognitionException {
     StringContext _localctx = new StringContext(_ctx, getState());
-    enterRule(_localctx, 54, RULE_string);
+    enterRule(_localctx, 52, RULE_string);
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(278);
+      setState(275);
       match(STRING);
       }
     }
@@ -2469,7 +2424,7 @@ public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
     switch (ruleIndex) {
     case 14:
       return booleanExpression_sempred((BooleanExpressionContext)_localctx, predIndex);
-    case 17:
+    case 15:
       return valueExpression_sempred((ValueExpressionContext)_localctx, predIndex);
     }
     return true;
@@ -2496,103 +2451,101 @@ private boolean valueExpression_sempred(ValueExpressionContext _localctx, int pr
   }
 
   public static final String _serializedATN =
-    "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3,\u011b\4\2\t\2\4"+
+    "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3,\u0118\4\2\t\2\4"+
     "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
     "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
     "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
-    "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\3\2\3\2\3\2\3\3\3\3\3\3\3\4\3"+
-    "\4\7\4C\n\4\f\4\16\4F\13\4\3\5\3\5\3\5\5\5K\n\5\3\6\3\6\3\6\3\6\3\6\3"+
-    "\7\3\7\3\7\5\7U\n\7\3\7\3\7\5\7Y\n\7\5\7[\n\7\3\7\3\7\6\7_\n\7\r\7\16"+
-    "\7`\3\7\3\7\5\7e\n\7\3\b\3\b\5\bi\n\b\3\b\3\b\6\bm\n\b\r\b\16\bn\3\b\3"+
-    "\b\5\bs\n\b\3\t\3\t\3\t\3\t\3\t\7\tz\n\t\f\t\16\t}\13\t\5\t\177\n\t\3"+
-    "\n\3\n\3\n\3\n\7\n\u0085\n\n\f\n\16\n\u0088\13\n\3\13\3\13\5\13\u008c"+
-    "\n\13\3\f\3\f\3\f\3\f\5\f\u0092\n\f\5\f\u0094\n\f\3\f\5\f\u0097\n\f\3"+
-    "\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\17\3\17\3\20\3\20\3\20\3\20\3\20"+
-    "\3\20\3\20\5\20\u00aa\n\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u00b2\n"+
-    "\20\f\20\16\20\u00b5\13\20\3\21\3\21\5\21\u00b9\n\21\3\22\5\22\u00bc\n"+
-    "\22\3\22\3\22\3\22\3\22\3\22\7\22\u00c3\n\22\f\22\16\22\u00c6\13\22\3"+
-    "\22\3\22\3\23\3\23\3\23\3\23\5\23\u00ce\n\23\3\23\3\23\3\23\3\23\3\23"+
-    "\3\23\3\23\3\23\3\23\3\23\7\23\u00da\n\23\f\23\16\23\u00dd\13\23\3\24"+
-    "\3\24\3\24\3\24\3\24\3\24\3\24\5\24\u00e6\n\24\3\25\3\25\3\25\3\25\3\25"+
-    "\7\25\u00ed\n\25\f\25\16\25\u00f0\13\25\5\25\u00f2\n\25\3\25\3\25\3\26"+
-    "\3\26\3\26\3\26\5\26\u00fa\n\26\3\27\3\27\3\30\3\30\3\31\3\31\3\31\3\31"+
-    "\3\31\6\31\u0105\n\31\r\31\16\31\u0106\3\31\7\31\u010a\n\31\f\31\16\31"+
-    "\u010d\13\31\3\32\3\32\3\33\3\33\5\33\u0113\n\33\3\34\3\34\5\34\u0117"+
-    "\n\34\3\35\3\35\3\35\2\4\36$\36\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36"+
-    " \"$&(*,.\60\62\64\668\2\7\3\2\31\32\3\2\33\35\3\2\23\30\4\2\5\5\17\17"+
-    "\4\2%%))\u0129\2:\3\2\2\2\4=\3\2\2\2\6@\3\2\2\2\bJ\3\2\2\2\nL\3\2\2\2"+
-    "\fQ\3\2\2\2\16f\3\2\2\2\20t\3\2\2\2\22\u0080\3\2\2\2\24\u0089\3\2\2\2"+
-    "\26\u008d\3\2\2\2\30\u0098\3\2\2\2\32\u009c\3\2\2\2\34\u00a0\3\2\2\2\36"+
-    "\u00a9\3\2\2\2 \u00b6\3\2\2\2\"\u00bb\3\2\2\2$\u00cd\3\2\2\2&\u00e5\3"+
-    "\2\2\2(\u00e7\3\2\2\2*\u00f9\3\2\2\2,\u00fb\3\2\2\2.\u00fd\3\2\2\2\60"+
-    "\u00ff\3\2\2\2\62\u010e\3\2\2\2\64\u0110\3\2\2\2\66\u0116\3\2\2\28\u0118"+
-    "\3\2\2\2:;\5\6\4\2;<\7\2\2\3<\3\3\2\2\2=>\5\34\17\2>?\7\2\2\3?\5\3\2\2"+
-    "\2@D\5\b\5\2AC\5\20\t\2BA\3\2\2\2CF\3\2\2\2DB\3\2\2\2DE\3\2\2\2E\7\3\2"+
-    "\2\2FD\3\2\2\2GK\5\f\7\2HK\5\16\b\2IK\5\32\16\2JG\3\2\2\2JH\3\2\2\2JI"+
-    "\3\2\2\2K\t\3\2\2\2LM\7\22\2\2MN\7\t\2\2NO\7\23\2\2OP\5\64\33\2P\13\3"+
-    "\2\2\2QZ\7\16\2\2RT\5\22\n\2SU\5\n\6\2TS\3\2\2\2TU\3\2\2\2U[\3\2\2\2V"+
-    "X\5\n\6\2WY\5\22\n\2XW\3\2\2\2XY\3\2\2\2Y[\3\2\2\2ZR\3\2\2\2ZV\3\2\2\2"+
-    "Z[\3\2\2\2[\\\3\2\2\2\\^\5\26\f\2]_\5\26\f\2^]\3\2\2\2_`\3\2\2\2`^\3\2"+
-    "\2\2`a\3\2\2\2ad\3\2\2\2bc\7\20\2\2ce\5\26\f\2db\3\2\2\2de\3\2\2\2e\r"+
-    "\3\2\2\2fh\7\b\2\2gi\5\22\n\2hg\3\2\2\2hi\3\2\2\2ij\3\2\2\2jl\5\24\13"+
-    "\2km\5\24\13\2lk\3\2\2\2mn\3\2\2\2nl\3\2\2\2no\3\2\2\2or\3\2\2\2pq\7\20"+
-    "\2\2qs\5\24\13\2rp\3\2\2\2rs\3\2\2\2s\17\3\2\2\2tu\7$\2\2u~\7)\2\2v{\5"+
-    "\36\20\2wx\7\37\2\2xz\5\36\20\2yw\3\2\2\2z}\3\2\2\2{y\3\2\2\2{|\3\2\2"+
-    "\2|\177\3\2\2\2}{\3\2\2\2~v\3\2\2\2~\177\3\2\2\2\177\21\3\2\2\2\u0080"+
-    "\u0081\7\4\2\2\u0081\u0086\5\34\17\2\u0082\u0083\7\37\2\2\u0083\u0085"+
-    "\5\34\17\2\u0084\u0082\3\2\2\2\u0085\u0088\3\2\2\2\u0086\u0084\3\2\2\2"+
-    "\u0086\u0087\3\2\2\2\u0087\23\3\2\2\2\u0088\u0086\3\2\2\2\u0089\u008b"+
-    "\5\30\r\2\u008a\u008c\5\22\n\2\u008b\u008a\3\2\2\2\u008b\u008c\3\2\2\2"+
-    "\u008c\25\3\2\2\2\u008d\u0093\5\30\r\2\u008e\u0091\7\6\2\2\u008f\u0090"+
-    "\7\23\2\2\u0090\u0092\5.\30\2\u0091\u008f\3\2\2\2\u0091\u0092\3\2\2\2"+
-    "\u0092\u0094\3\2\2\2\u0093\u008e\3\2\2\2\u0093\u0094\3\2\2\2\u0094\u0096"+
-    "\3\2\2\2\u0095\u0097\5\22\n\2\u0096\u0095\3\2\2\2\u0096\u0097\3\2\2\2"+
-    "\u0097\27\3\2\2\2\u0098\u0099\7 \2\2\u0099\u009a\5\32\16\2\u009a\u009b"+
-    "\7!\2\2\u009b\31\3\2\2\2\u009c\u009d\5\62\32\2\u009d\u009e\7\21\2\2\u009e"+
-    "\u009f\5\34\17\2\u009f\33\3\2\2\2\u00a0\u00a1\5\36\20\2\u00a1\35\3\2\2"+
-    "\2\u00a2\u00a3\b\20\1\2\u00a3\u00a4\7\n\2\2\u00a4\u00aa\5\36\20\7\u00a5"+
-    "\u00a6\7)\2\2\u00a6\u00a7\7\f\2\2\u00a7\u00aa\5\30\r\2\u00a8\u00aa\5 "+
-    "\21\2\u00a9\u00a2\3\2\2\2\u00a9\u00a5\3\2\2\2\u00a9\u00a8\3\2\2\2\u00aa"+
-    "\u00b3\3\2\2\2\u00ab\u00ac\f\4\2\2\u00ac\u00ad\7\3\2\2\u00ad\u00b2\5\36"+
-    "\20\5\u00ae\u00af\f\3\2\2\u00af\u00b0\7\r\2\2\u00b0\u00b2\5\36\20\4\u00b1"+
-    "\u00ab\3\2\2\2\u00b1\u00ae\3\2\2\2\u00b2\u00b5\3\2\2\2\u00b3\u00b1\3\2"+
-    "\2\2\u00b3\u00b4\3\2\2\2\u00b4\37\3\2\2\2\u00b5\u00b3\3\2\2\2\u00b6\u00b8"+
-    "\5$\23\2\u00b7\u00b9\5\"\22\2\u00b8\u00b7\3\2\2\2\u00b8\u00b9\3\2\2\2"+
-    "\u00b9!\3\2\2\2\u00ba\u00bc\7\n\2\2\u00bb\u00ba\3\2\2\2\u00bb\u00bc\3"+
-    "\2\2\2\u00bc\u00bd\3\2\2\2\u00bd\u00be\7\7\2\2\u00be\u00bf\7\"\2\2\u00bf"+
-    "\u00c4\5$\23\2\u00c0\u00c1\7\37\2\2\u00c1\u00c3\5$\23\2\u00c2\u00c0\3"+
-    "\2\2\2\u00c3\u00c6\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5"+
-    "\u00c7\3\2\2\2\u00c6\u00c4\3\2\2\2\u00c7\u00c8\7#\2\2\u00c8#\3\2\2\2\u00c9"+
-    "\u00ca\b\23\1\2\u00ca\u00ce\5&\24\2\u00cb\u00cc\t\2\2\2\u00cc\u00ce\5"+
-    "$\23\6\u00cd\u00c9\3\2\2\2\u00cd\u00cb\3\2\2\2\u00ce\u00db\3\2\2\2\u00cf"+
-    "\u00d0\f\5\2\2\u00d0\u00d1\t\3\2\2\u00d1\u00da\5$\23\6\u00d2\u00d3\f\4"+
-    "\2\2\u00d3\u00d4\t\2\2\2\u00d4\u00da\5$\23\5\u00d5\u00d6\f\3\2\2\u00d6"+
-    "\u00d7\5,\27\2\u00d7\u00d8\5$\23\4\u00d8\u00da\3\2\2\2\u00d9\u00cf\3\2"+
-    "\2\2\u00d9\u00d2\3\2\2\2\u00d9\u00d5\3\2\2\2\u00da\u00dd\3\2\2\2\u00db"+
-    "\u00d9\3\2\2\2\u00db\u00dc\3\2\2\2\u00dc%\3\2\2\2\u00dd\u00db\3\2\2\2"+
-    "\u00de\u00e6\5*\26\2\u00df\u00e6\5(\25\2\u00e0\u00e6\5\60\31\2\u00e1\u00e2"+
-    "\7\"\2\2\u00e2\u00e3\5\34\17\2\u00e3\u00e4\7#\2\2\u00e4\u00e6\3\2\2\2"+
-    "\u00e5\u00de\3\2\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1"+
-    "\3\2\2\2\u00e6\'\3\2\2\2\u00e7\u00e8\7)\2\2\u00e8\u00f1\7\"\2\2\u00e9"+
-    "\u00ee\5\34\17\2\u00ea\u00eb\7\37\2\2\u00eb\u00ed\5\34\17\2\u00ec\u00ea"+
-    "\3\2\2\2\u00ed\u00f0\3\2\2\2\u00ee\u00ec\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef"+
-    "\u00f2\3\2\2\2\u00f0\u00ee\3\2\2\2\u00f1\u00e9\3\2\2\2\u00f1\u00f2\3\2"+
-    "\2\2\u00f2\u00f3\3\2\2\2\u00f3\u00f4\7#\2\2\u00f4)\3\2\2\2\u00f5\u00fa"+
-    "\7\13\2\2\u00f6\u00fa\5\66\34\2\u00f7\u00fa\5.\30\2\u00f8\u00fa\58\35"+
-    "\2\u00f9\u00f5\3\2\2\2\u00f9\u00f6\3\2\2\2\u00f9\u00f7\3\2\2\2\u00f9\u00f8"+
-    "\3\2\2\2\u00fa+\3\2\2\2\u00fb\u00fc\t\4\2\2\u00fc-\3\2\2\2\u00fd\u00fe"+
-    "\t\5\2\2\u00fe/\3\2\2\2\u00ff\u010b\5\62\32\2\u0100\u0101\7\36\2\2\u0101"+
-    "\u010a\5\62\32\2\u0102\u0104\7 \2\2\u0103\u0105\7\'\2\2\u0104\u0103\3"+
-    "\2\2\2\u0105\u0106\3\2\2\2\u0106\u0104\3\2\2\2\u0106\u0107\3\2\2\2\u0107"+
-    "\u0108\3\2\2\2\u0108\u010a\7!\2\2\u0109\u0100\3\2\2\2\u0109\u0102\3\2"+
-    "\2\2\u010a\u010d\3\2\2\2\u010b\u0109\3\2\2\2\u010b\u010c\3\2\2\2\u010c"+
-    "\61\3\2\2\2\u010d\u010b\3\2\2\2\u010e\u010f\t\6\2\2\u010f\63\3\2\2\2\u0110"+
-    "\u0112\5\66\34\2\u0111\u0113\7)\2\2\u0112\u0111\3\2\2\2\u0112\u0113\3"+
-    "\2\2\2\u0113\65\3\2\2\2\u0114\u0117\7(\2\2\u0115\u0117\7\'\2\2\u0116\u0114"+
-    "\3\2\2\2\u0116\u0115\3\2\2\2\u0117\67\3\2\2\2\u0118\u0119\7&\2\2\u0119"+
-    "9\3\2\2\2%DJTXZ`dhnr{~\u0086\u008b\u0091\u0093\u0096\u00a9\u00b1\u00b3"+
-    "\u00b8\u00bb\u00c4\u00cd\u00d9\u00db\u00e5\u00ee\u00f1\u00f9\u0106\u0109"+
-    "\u010b\u0112\u0116";
+    "\4\32\t\32\4\33\t\33\4\34\t\34\3\2\3\2\3\2\3\3\3\3\3\3\3\4\3\4\7\4A\n"+
+    "\4\f\4\16\4D\13\4\3\5\3\5\3\5\5\5I\n\5\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7"+
+    "\5\7S\n\7\3\7\3\7\5\7W\n\7\5\7Y\n\7\3\7\3\7\6\7]\n\7\r\7\16\7^\3\7\3\7"+
+    "\5\7c\n\7\3\b\3\b\5\bg\n\b\3\b\3\b\6\bk\n\b\r\b\16\bl\3\b\3\b\5\bq\n\b"+
+    "\3\t\3\t\3\t\3\t\3\t\7\tx\n\t\f\t\16\t{\13\t\5\t}\n\t\3\n\3\n\3\n\3\n"+
+    "\7\n\u0083\n\n\f\n\16\n\u0086\13\n\3\13\3\13\5\13\u008a\n\13\3\f\3\f\3"+
+    "\f\3\f\5\f\u0090\n\f\5\f\u0092\n\f\3\f\5\f\u0095\n\f\3\r\3\r\3\r\3\r\3"+
+    "\16\3\16\3\16\3\16\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u00a8"+
+    "\n\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u00b0\n\20\f\20\16\20\u00b3\13"+
+    "\20\3\21\3\21\3\21\5\21\u00b8\n\21\3\21\3\21\5\21\u00bc\n\21\3\21\3\21"+
+    "\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\7\21\u00c8\n\21\f\21\16\21\u00cb"+
+    "\13\21\3\22\5\22\u00ce\n\22\3\22\3\22\3\22\3\22\3\22\7\22\u00d5\n\22\f"+
+    "\22\16\22\u00d8\13\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23"+
+    "\u00e3\n\23\3\24\3\24\3\24\3\24\3\24\7\24\u00ea\n\24\f\24\16\24\u00ed"+
+    "\13\24\5\24\u00ef\n\24\3\24\3\24\3\25\3\25\3\25\3\25\5\25\u00f7\n\25\3"+
+    "\26\3\26\3\27\3\27\3\30\3\30\3\30\3\30\3\30\6\30\u0102\n\30\r\30\16\30"+
+    "\u0103\3\30\7\30\u0107\n\30\f\30\16\30\u010a\13\30\3\31\3\31\3\32\3\32"+
+    "\5\32\u0110\n\32\3\33\3\33\5\33\u0114\n\33\3\34\3\34\3\34\2\4\36 \35\2"+
+    "\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\66\2\7\3\2\31"+
+    "\32\3\2\33\35\3\2\23\30\4\2\5\5\17\17\4\2%%))\u0127\28\3\2\2\2\4;\3\2"+
+    "\2\2\6>\3\2\2\2\bH\3\2\2\2\nJ\3\2\2\2\fO\3\2\2\2\16d\3\2\2\2\20r\3\2\2"+
+    "\2\22~\3\2\2\2\24\u0087\3\2\2\2\26\u008b\3\2\2\2\30\u0096\3\2\2\2\32\u009a"+
+    "\3\2\2\2\34\u009e\3\2\2\2\36\u00a7\3\2\2\2 \u00bb\3\2\2\2\"\u00cd\3\2"+
+    "\2\2$\u00e2\3\2\2\2&\u00e4\3\2\2\2(\u00f6\3\2\2\2*\u00f8\3\2\2\2,\u00fa"+
+    "\3\2\2\2.\u00fc\3\2\2\2\60\u010b\3\2\2\2\62\u010d\3\2\2\2\64\u0113\3\2"+
+    "\2\2\66\u0115\3\2\2\289\5\6\4\29:\7\2\2\3:\3\3\2\2\2;<\5\34\17\2<=\7\2"+
+    "\2\3=\5\3\2\2\2>B\5\b\5\2?A\5\20\t\2@?\3\2\2\2AD\3\2\2\2B@\3\2\2\2BC\3"+
+    "\2\2\2C\7\3\2\2\2DB\3\2\2\2EI\5\f\7\2FI\5\16\b\2GI\5\32\16\2HE\3\2\2\2"+
+    "HF\3\2\2\2HG\3\2\2\2I\t\3\2\2\2JK\7\22\2\2KL\7\t\2\2LM\7\23\2\2MN\5\62"+
+    "\32\2N\13\3\2\2\2OX\7\16\2\2PR\5\22\n\2QS\5\n\6\2RQ\3\2\2\2RS\3\2\2\2"+
+    "SY\3\2\2\2TV\5\n\6\2UW\5\22\n\2VU\3\2\2\2VW\3\2\2\2WY\3\2\2\2XP\3\2\2"+
+    "\2XT\3\2\2\2XY\3\2\2\2YZ\3\2\2\2Z\\\5\26\f\2[]\5\26\f\2\\[\3\2\2\2]^\3"+
+    "\2\2\2^\\\3\2\2\2^_\3\2\2\2_b\3\2\2\2`a\7\20\2\2ac\5\26\f\2b`\3\2\2\2"+
+    "bc\3\2\2\2c\r\3\2\2\2df\7\b\2\2eg\5\22\n\2fe\3\2\2\2fg\3\2\2\2gh\3\2\2"+
+    "\2hj\5\24\13\2ik\5\24\13\2ji\3\2\2\2kl\3\2\2\2lj\3\2\2\2lm\3\2\2\2mp\3"+
+    "\2\2\2no\7\20\2\2oq\5\24\13\2pn\3\2\2\2pq\3\2\2\2q\17\3\2\2\2rs\7$\2\2"+
+    "s|\7)\2\2ty\5\36\20\2uv\7\37\2\2vx\5\36\20\2wu\3\2\2\2x{\3\2\2\2yw\3\2"+
+    "\2\2yz\3\2\2\2z}\3\2\2\2{y\3\2\2\2|t\3\2\2\2|}\3\2\2\2}\21\3\2\2\2~\177"+
+    "\7\4\2\2\177\u0084\5\34\17\2\u0080\u0081\7\37\2\2\u0081\u0083\5\34\17"+
+    "\2\u0082\u0080\3\2\2\2\u0083\u0086\3\2\2\2\u0084\u0082\3\2\2\2\u0084\u0085"+
+    "\3\2\2\2\u0085\23\3\2\2\2\u0086\u0084\3\2\2\2\u0087\u0089\5\30\r\2\u0088"+
+    "\u008a\5\22\n\2\u0089\u0088\3\2\2\2\u0089\u008a\3\2\2\2\u008a\25\3\2\2"+
+    "\2\u008b\u0091\5\30\r\2\u008c\u008f\7\6\2\2\u008d\u008e\7\23\2\2\u008e"+
+    "\u0090\5,\27\2\u008f\u008d\3\2\2\2\u008f\u0090\3\2\2\2\u0090\u0092\3\2"+
+    "\2\2\u0091\u008c\3\2\2\2\u0091\u0092\3\2\2\2\u0092\u0094\3\2\2\2\u0093"+
+    "\u0095\5\22\n\2\u0094\u0093\3\2\2\2\u0094\u0095\3\2\2\2\u0095\27\3\2\2"+
+    "\2\u0096\u0097\7 \2\2\u0097\u0098\5\32\16\2\u0098\u0099\7!\2\2\u0099\31"+
+    "\3\2\2\2\u009a\u009b\5\60\31\2\u009b\u009c\7\21\2\2\u009c\u009d\5\34\17"+
+    "\2\u009d\33\3\2\2\2\u009e\u009f\5\36\20\2\u009f\35\3\2\2\2\u00a0\u00a1"+
+    "\b\20\1\2\u00a1\u00a2\7\n\2\2\u00a2\u00a8\5\36\20\7\u00a3\u00a4\7)\2\2"+
+    "\u00a4\u00a5\7\f\2\2\u00a5\u00a8\5\30\r\2\u00a6\u00a8\5 \21\2\u00a7\u00a0"+
+    "\3\2\2\2\u00a7\u00a3\3\2\2\2\u00a7\u00a6\3\2\2\2\u00a8\u00b1\3\2\2\2\u00a9"+
+    "\u00aa\f\4\2\2\u00aa\u00ab\7\3\2\2\u00ab\u00b0\5\36\20\5\u00ac\u00ad\f"+
+    "\3\2\2\u00ad\u00ae\7\r\2\2\u00ae\u00b0\5\36\20\4\u00af\u00a9\3\2\2\2\u00af"+
+    "\u00ac\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+
+    "\2\2\u00b2\37\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\b\21\1\2\u00b5\u00b7"+
+    "\5$\23\2\u00b6\u00b8\5\"\22\2\u00b7\u00b6\3\2\2\2\u00b7\u00b8\3\2\2\2"+
+    "\u00b8\u00bc\3\2\2\2\u00b9\u00ba\t\2\2\2\u00ba\u00bc\5 \21\6\u00bb\u00b4"+
+    "\3\2\2\2\u00bb\u00b9\3\2\2\2\u00bc\u00c9\3\2\2\2\u00bd\u00be\f\5\2\2\u00be"+
+    "\u00bf\t\3\2\2\u00bf\u00c8\5 \21\6\u00c0\u00c1\f\4\2\2\u00c1\u00c2\t\2"+
+    "\2\2\u00c2\u00c8\5 \21\5\u00c3\u00c4\f\3\2\2\u00c4\u00c5\5*\26\2\u00c5"+
+    "\u00c6\5 \21\4\u00c6\u00c8\3\2\2\2\u00c7\u00bd\3\2\2\2\u00c7\u00c0\3\2"+
+    "\2\2\u00c7\u00c3\3\2\2\2\u00c8\u00cb\3\2\2\2\u00c9\u00c7\3\2\2\2\u00c9"+
+    "\u00ca\3\2\2\2\u00ca!\3\2\2\2\u00cb\u00c9\3\2\2\2\u00cc\u00ce\7\n\2\2"+
+    "\u00cd\u00cc\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00d0"+
+    "\7\7\2\2\u00d0\u00d1\7\"\2\2\u00d1\u00d6\5\34\17\2\u00d2\u00d3\7\37\2"+
+    "\2\u00d3\u00d5\5\34\17\2\u00d4\u00d2\3\2\2\2\u00d5\u00d8\3\2\2\2\u00d6"+
+    "\u00d4\3\2\2\2\u00d6\u00d7\3\2\2\2\u00d7\u00d9\3\2\2\2\u00d8\u00d6\3\2"+
+    "\2\2\u00d9\u00da\7#\2\2\u00da#\3\2\2\2\u00db\u00e3\5(\25\2\u00dc\u00e3"+
+    "\5&\24\2\u00dd\u00e3\5.\30\2\u00de\u00df\7\"\2\2\u00df\u00e0\5\34\17\2"+
+    "\u00e0\u00e1\7#\2\2\u00e1\u00e3\3\2\2\2\u00e2\u00db\3\2\2\2\u00e2\u00dc"+
+    "\3\2\2\2\u00e2\u00dd\3\2\2\2\u00e2\u00de\3\2\2\2\u00e3%\3\2\2\2\u00e4"+
+    "\u00e5\7)\2\2\u00e5\u00ee\7\"\2\2\u00e6\u00eb\5\34\17\2\u00e7\u00e8\7"+
+    "\37\2\2\u00e8\u00ea\5\34\17\2\u00e9\u00e7\3\2\2\2\u00ea\u00ed\3\2\2\2"+
+    "\u00eb\u00e9\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ef\3\2\2\2\u00ed\u00eb"+
+    "\3\2\2\2\u00ee\u00e6\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0"+
+    "\u00f1\7#\2\2\u00f1\'\3\2\2\2\u00f2\u00f7\7\13\2\2\u00f3\u00f7\5\64\33"+
+    "\2\u00f4\u00f7\5,\27\2\u00f5\u00f7\5\66\34\2\u00f6\u00f2\3\2\2\2\u00f6"+
+    "\u00f3\3\2\2\2\u00f6\u00f4\3\2\2\2\u00f6\u00f5\3\2\2\2\u00f7)\3\2\2\2"+
+    "\u00f8\u00f9\t\4\2\2\u00f9+\3\2\2\2\u00fa\u00fb\t\5\2\2\u00fb-\3\2\2\2"+
+    "\u00fc\u0108\5\60\31\2\u00fd\u00fe\7\36\2\2\u00fe\u0107\5\60\31\2\u00ff"+
+    "\u0101\7 \2\2\u0100\u0102\7\'\2\2\u0101\u0100\3\2\2\2\u0102\u0103\3\2"+
+    "\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0105\3\2\2\2\u0105"+
+    "\u0107\7!\2\2\u0106\u00fd\3\2\2\2\u0106\u00ff\3\2\2\2\u0107\u010a\3\2"+
+    "\2\2\u0108\u0106\3\2\2\2\u0108\u0109\3\2\2\2\u0109/\3\2\2\2\u010a\u0108"+
+    "\3\2\2\2\u010b\u010c\t\6\2\2\u010c\61\3\2\2\2\u010d\u010f\5\64\33\2\u010e"+
+    "\u0110\7)\2\2\u010f\u010e\3\2\2\2\u010f\u0110\3\2\2\2\u0110\63\3\2\2\2"+
+    "\u0111\u0114\7(\2\2\u0112\u0114\7\'\2\2\u0113\u0111\3\2\2\2\u0113\u0112"+
+    "\3\2\2\2\u0114\65\3\2\2\2\u0115\u0116\7&\2\2\u0116\67\3\2\2\2%BHRVX^b"+
+    "flpy|\u0084\u0089\u008f\u0091\u0094\u00a7\u00af\u00b1\u00b7\u00bb\u00c7"+
+    "\u00c9\u00cd\u00d6\u00e2\u00eb\u00ee\u00f6\u0103\u0106\u0108\u010f\u0113";
   public static final ATN _ATN =
     new ATNDeserializer().deserialize(_serializedATN.toCharArray());
   static {
diff --git a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseVisitor.java b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseVisitor.java
index ec386d12c1c38..8e5287a0f6632 100644
--- a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseVisitor.java
+++ b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlBaseVisitor.java
@@ -122,18 +122,6 @@ interface EqlBaseVisitor<T> extends ParseTreeVisitor<T> {
    * @return the visitor result
    */
   T visitLogicalBinary(EqlBaseParser.LogicalBinaryContext ctx);
-  /**
-   * Visit a parse tree produced by {@link EqlBaseParser#predicated}.
-   * @param ctx the parse tree
-   * @return the visitor result
-   */
-  T visitPredicated(EqlBaseParser.PredicatedContext ctx);
-  /**
-   * Visit a parse tree produced by {@link EqlBaseParser#predicate}.
-   * @param ctx the parse tree
-   * @return the visitor result
-   */
-  T visitPredicate(EqlBaseParser.PredicateContext ctx);
   /**
    * Visit a parse tree produced by the {@code valueExpressionDefault}
    * labeled alternative in {@link EqlBaseParser#valueExpression}.
@@ -162,6 +150,12 @@ interface EqlBaseVisitor<T> extends ParseTreeVisitor<T> {
    * @return the visitor result
    */
   T visitArithmeticUnary(EqlBaseParser.ArithmeticUnaryContext ctx);
+  /**
+   * Visit a parse tree produced by {@link EqlBaseParser#predicate}.
+   * @param ctx the parse tree
+   * @return the visitor result
+   */
+  T visitPredicate(EqlBaseParser.PredicateContext ctx);
   /**
    * Visit a parse tree produced by the {@code constantDefault}
    * labeled alternative in {@link EqlBaseParser#primaryExpression}.
diff --git a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlParser.java b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlParser.java
index 1f82b63e01de3..d524564250fdb 100644
--- a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlParser.java
+++ b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/EqlParser.java
@@ -5,6 +5,7 @@
  */
 package org.elasticsearch.xpack.eql.parser;
 
+import org.antlr.v4.runtime.ANTLRInputStream;
 import org.antlr.v4.runtime.BaseErrorListener;
 import org.antlr.v4.runtime.CommonTokenStream;
 import org.antlr.v4.runtime.DiagnosticErrorListener;
@@ -18,8 +19,8 @@
 import org.antlr.v4.runtime.dfa.DFA;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.antlr.v4.runtime.ANTLRInputStream;
 import org.elasticsearch.xpack.ql.expression.Expression;
+import org.elasticsearch.xpack.ql.plan.logical.LogicalPlan;
 
 import java.util.Arrays;
 import java.util.BitSet;
@@ -40,11 +41,11 @@ public class EqlParser {
      * Parses an EQL statement into execution plan
      * @param eql - the EQL statement
      */
-    public Expression createStatement(String eql) {
+    public LogicalPlan createStatement(String eql) {
         if (log.isDebugEnabled()) {
             log.debug("Parsing as statement: {}", eql);
         }
-        return invokeParser(eql, EqlBaseParser::singleStatement, AstBuilder::expression);
+        return invokeParser(eql, EqlBaseParser::singleStatement, AstBuilder::plan);
     }
 
     public Expression createExpression(String expression) {
diff --git a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/ExpressionBuilder.java b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/ExpressionBuilder.java
index c516ccb01e179..6510fdc3561c7 100644
--- a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/ExpressionBuilder.java
+++ b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/ExpressionBuilder.java
@@ -6,6 +6,237 @@
 
 package org.elasticsearch.xpack.eql.parser;
 
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.TerminalNode;
+import org.elasticsearch.xpack.eql.parser.EqlBaseParser.ArithmeticUnaryContext;
+import org.elasticsearch.xpack.eql.parser.EqlBaseParser.ComparisonContext;
+import org.elasticsearch.xpack.eql.parser.EqlBaseParser.DereferenceContext;
+import org.elasticsearch.xpack.eql.parser.EqlBaseParser.FunctionExpressionContext;
+import org.elasticsearch.xpack.eql.parser.EqlBaseParser.LogicalBinaryContext;
+import org.elasticsearch.xpack.eql.parser.EqlBaseParser.LogicalNotContext;
+import org.elasticsearch.xpack.eql.parser.EqlBaseParser.PredicateContext;
+import org.elasticsearch.xpack.eql.parser.EqlBaseParser.ValueExpressionDefaultContext;
+import org.elasticsearch.xpack.ql.QlIllegalArgumentException;
+import org.elasticsearch.xpack.ql.expression.Expression;
+import org.elasticsearch.xpack.ql.expression.Literal;
+import org.elasticsearch.xpack.ql.expression.UnresolvedAttribute;
+import org.elasticsearch.xpack.ql.expression.function.Function;
+import org.elasticsearch.xpack.ql.expression.function.UnresolvedFunction;
+import org.elasticsearch.xpack.ql.expression.predicate.logical.And;
+import org.elasticsearch.xpack.ql.expression.predicate.logical.Not;
+import org.elasticsearch.xpack.ql.expression.predicate.logical.Or;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.arithmetic.Add;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.arithmetic.Div;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.arithmetic.Mod;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.arithmetic.Mul;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.arithmetic.Neg;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.arithmetic.Sub;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.comparison.Equals;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.comparison.GreaterThan;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.comparison.GreaterThanOrEqual;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.comparison.LessThan;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.comparison.LessThanOrEqual;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.comparison.NotEquals;
+import org.elasticsearch.xpack.ql.tree.Source;
+import org.elasticsearch.xpack.ql.type.DataType;
+import org.elasticsearch.xpack.ql.type.DataTypes;
+import org.elasticsearch.xpack.ql.util.StringUtils;
+
+import java.util.List;
+
+
 public class ExpressionBuilder extends IdentifierBuilder {
 
+    protected Expression expression(ParseTree ctx) {
+        return typedParsing(ctx, Expression.class);
+    }
+
+    protected List<Expression> expressions(List<? extends ParserRuleContext> contexts) {
+        return visitList(contexts, Expression.class);
+    }
+
+    @Override
+    public Expression visitSingleExpression(EqlBaseParser.SingleExpressionContext ctx) {
+        return expression(ctx.expression());
+    }
+
+    @Override
+    public Expression visitArithmeticUnary(ArithmeticUnaryContext ctx) {
+        Expression expr = expression(ctx.valueExpression());
+        Source source = source(ctx);
+        int type = ctx.operator.getType();
+
+        return type == EqlBaseParser.MINUS ? new Neg(source, expr) : expr;
+    }
+
+    @Override
+    public Expression visitArithmeticBinary(EqlBaseParser.ArithmeticBinaryContext ctx) {
+        Expression left = expression(ctx.left);
+        Expression right = expression(ctx.right);
+        Source source = source(ctx);
+        int type = ctx.operator.getType();
+
+        switch (type) {
+            case EqlBaseParser.ASTERISK:
+                return new Mul(source, left, right);
+            case EqlBaseParser.SLASH:
+                return new Div(source, left, right);
+            case EqlBaseParser.PERCENT:
+                return new Mod(source, left, right);
+            case EqlBaseParser.PLUS:
+                return new Add(source, left, right);
+            case EqlBaseParser.MINUS:
+                return new Sub(source, left, right);
+            default:
+                throw new ParsingException(source, "Unknown arithmetic {}", source.text());
+        }
+    }
+
+    @Override
+    public Literal visitBooleanValue(EqlBaseParser.BooleanValueContext ctx) {
+        Source source = source(ctx);
+        return new Literal(source, ctx.TRUE() != null, DataTypes.BOOLEAN);
+    }
+
+    @Override
+    public Expression visitComparison(ComparisonContext ctx) {
+        Expression left = expression(ctx.left);
+        Expression right = expression(ctx.right);
+        TerminalNode op = (TerminalNode) ctx.comparisonOperator().getChild(0);
+
+        Source source = source(ctx);
+
+        switch (op.getSymbol().getType()) {
+            case EqlBaseParser.EQ:
+                return new Equals(source, left, right);
+            case EqlBaseParser.NEQ:
+                return new NotEquals(source, left, right);
+            case EqlBaseParser.LT:
+                return new LessThan(source, left, right);
+            case EqlBaseParser.LTE:
+                return new LessThanOrEqual(source, left, right);
+            case EqlBaseParser.GT:
+                return new GreaterThan(source, left, right);
+            case EqlBaseParser.GTE:
+                return new GreaterThanOrEqual(source, left, right);
+            default:
+                throw new ParsingException(source, "Unknown operator {}", source.text());
+        }
+    }
+
+    @Override
+    public Expression visitValueExpressionDefault(ValueExpressionDefaultContext ctx) {
+        Expression expr = expression(ctx.primaryExpression());
+        Source source = source(ctx);
+
+        PredicateContext predicate = ctx.predicate();
+
+        if (predicate == null) {
+            return expr;
+        }
+
+        List<Expression> container = expressions(predicate.expression());
+
+        // TODO: Add IN to QL and use that directly
+        Expression checkInSet = null;
+
+        for (Expression inner : container) {
+            Expression termCheck = new Equals(source, expr, inner);
+            checkInSet = checkInSet == null ? termCheck : new Or(source, checkInSet, termCheck);
+        }
+
+        return predicate.NOT() != null ? new Not(source, checkInSet) : checkInSet;
+    }
+
+    @Override
+    public Expression visitDecimalLiteral(EqlBaseParser.DecimalLiteralContext ctx) {
+        Source source = source(ctx);
+        String text = ctx.getText();
+
+        try {
+            return new Literal(source, Double.valueOf(StringUtils.parseDouble(text)), DataTypes.DOUBLE);
+        } catch (QlIllegalArgumentException siae) {
+            throw new ParsingException(source, siae.getMessage());
+        }
+    }
+
+    @Override
+    public Expression visitDereference(DereferenceContext ctx) {
+        return new UnresolvedAttribute(source(ctx), visitQualifiedName(ctx.qualifiedName()));
+    }
+
+    @Override
+    public Function visitFunctionExpression(FunctionExpressionContext ctx) {
+        Source source = source(ctx);
+        String name = ctx.name.getText();
+        List<Expression> arguments = expressions(ctx.expression());
+
+        return new UnresolvedFunction(source, name, UnresolvedFunction.ResolutionType.STANDARD, arguments);
+    }
+
+    @Override
+    public Literal visitIntegerLiteral(EqlBaseParser.IntegerLiteralContext ctx) {
+        Source source = source(ctx);
+        String text = ctx.getText();
+
+        long value;
+
+        try {
+            value = Long.valueOf(StringUtils.parseLong(text));
+        } catch (QlIllegalArgumentException siae) {
+            // if it's too large, then quietly try to parse as a float instead
+            try {
+                return new Literal(source, Double.valueOf(StringUtils.parseDouble(text)), DataTypes.DOUBLE);
+            } catch (QlIllegalArgumentException ignored) {
+            }
+
+            throw new ParsingException(source, siae.getMessage());
+        }
+
+        Object val = Long.valueOf(value);
+        DataType type = DataTypes.LONG;
+
+        // try to downsize to int if possible (since that's the most common type)
+        if ((int) value == value) {
+            type = DataTypes.INTEGER;
+            val = Integer.valueOf((int) value);
+        }
+        return new Literal(source, val, type);
+    }
+
+    @Override
+    public Expression visitLogicalBinary(LogicalBinaryContext ctx) {
+        int type = ctx.operator.getType();
+        Source source = source(ctx);
+        Expression left = expression(ctx.left);
+        Expression right = expression(ctx.right);
+
+        if (type == EqlBaseParser.AND) {
+            return new And(source, left, right);
+        } else {
+            return new Or(source, left, right);
+        }
+    }
+
+    @Override
+    public Not visitLogicalNot(LogicalNotContext ctx) {
+        return new Not(source(ctx), expression(ctx.booleanExpression()));
+    }
+
+    @Override
+    public Literal visitNullLiteral(EqlBaseParser.NullLiteralContext ctx) {
+        Source source = source(ctx);
+        return new Literal(source, null, DataTypes.NULL);
+    }
+
+    @Override
+    public Expression visitParenthesizedExpression(EqlBaseParser.ParenthesizedExpressionContext ctx) {
+        return expression(ctx.expression());
+    }
+
+    @Override
+    public Literal visitString(EqlBaseParser.StringContext ctx) {
+        return new Literal(source(ctx), unquoteString(ctx.getText()), DataTypes.KEYWORD);
+    }
 }
diff --git a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/IdentifierBuilder.java b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/IdentifierBuilder.java
index 2d9511896356e..70a6ad3848a0c 100644
--- a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/IdentifierBuilder.java
+++ b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/IdentifierBuilder.java
@@ -5,7 +5,9 @@
  */
 package org.elasticsearch.xpack.eql.parser;
 
+import org.elasticsearch.common.Strings;
 import org.elasticsearch.xpack.eql.parser.EqlBaseParser.IdentifierContext;
+import org.elasticsearch.xpack.eql.parser.EqlBaseParser.QualifiedNameContext;
 
 abstract class IdentifierBuilder extends AbstractBuilder {
 
@@ -14,7 +16,17 @@ public String visitIdentifier(IdentifierContext ctx) {
         return ctx == null ? null : unquoteIdentifier(ctx.getText());
     }
 
+    @Override
+    public String visitQualifiedName(QualifiedNameContext ctx) {
+        if (ctx == null) {
+            return null;
+        }
+
+        // this is fine, because we've already checked for array indexes [...]
+        return Strings.collectionToDelimitedString(visitList(ctx.identifier(), String.class), ".");
+    }
+
     private static String unquoteIdentifier(String identifier) {
-        return identifier.replace("\"\"", "\"");
+        return identifier.replace("`", "");
     }
-}
\ No newline at end of file
+}
diff --git a/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/LogicalPlanBuilder.java b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/LogicalPlanBuilder.java
new file mode 100644
index 0000000000000..d87bf06c62855
--- /dev/null
+++ b/x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/LogicalPlanBuilder.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+package org.elasticsearch.xpack.eql.parser;
+
+import org.elasticsearch.xpack.ql.expression.Expression;
+import org.elasticsearch.xpack.ql.expression.Literal;
+import org.elasticsearch.xpack.ql.expression.UnresolvedAttribute;
+import org.elasticsearch.xpack.ql.expression.predicate.logical.And;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.comparison.Equals;
+import org.elasticsearch.xpack.ql.index.EsIndex;
+import org.elasticsearch.xpack.ql.plan.logical.EsRelation;
+import org.elasticsearch.xpack.ql.plan.logical.Filter;
+import org.elasticsearch.xpack.ql.plan.logical.LogicalPlan;
+import org.elasticsearch.xpack.ql.tree.Source;
+import org.elasticsearch.xpack.ql.type.DataTypes;
+
+import static java.util.Collections.emptyMap;
+
+public abstract class LogicalPlanBuilder extends ExpressionBuilder {
+
+    // TODO: these need to be made configurable
+    private static final String EVENT_TYPE = "event.category";
+    private static final EsIndex esIndex = new EsIndex("<not-specified>", emptyMap());
+
+    @Override
+    public LogicalPlan visitEventQuery(EqlBaseParser.EventQueryContext ctx) {
+        Source source = source(ctx);
+        Expression condition = expression(ctx.expression());
+
+        if (ctx.event != null) {
+            Source eventTypeSource = source(ctx.event);
+            String eventTypeName = visitIdentifier(ctx.event);
+            Literal eventTypeValue = new Literal(eventTypeSource, eventTypeName, DataTypes.KEYWORD);
+
+            UnresolvedAttribute eventTypeField = new UnresolvedAttribute(eventTypeSource, EVENT_TYPE);
+            Expression eventTypeCheck = new Equals(eventTypeSource, eventTypeField, eventTypeValue);
+
+            condition = new And(source, eventTypeCheck, condition);
+
+        }
+
+        return new Filter(source(ctx), new EsRelation(Source.EMPTY, esIndex, false), condition);
+    }
+}
diff --git a/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/parser/ExpressionTests.java b/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/parser/ExpressionTests.java
new file mode 100644
index 0000000000000..910078ea72d93
--- /dev/null
+++ b/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/parser/ExpressionTests.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+
+package org.elasticsearch.xpack.eql.parser;
+
+import org.elasticsearch.test.ESTestCase;
+import org.elasticsearch.xpack.ql.expression.Expression;
+import org.elasticsearch.xpack.ql.expression.Literal;
+import org.elasticsearch.xpack.ql.expression.UnresolvedAttribute;
+import org.elasticsearch.xpack.ql.expression.function.UnresolvedFunction;
+import org.elasticsearch.xpack.ql.expression.predicate.logical.And;
+import org.elasticsearch.xpack.ql.expression.predicate.logical.Or;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.arithmetic.Neg;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.comparison.Equals;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.comparison.GreaterThan;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.comparison.GreaterThanOrEqual;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.comparison.LessThan;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.comparison.LessThanOrEqual;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.comparison.NotEquals;
+import org.elasticsearch.xpack.ql.type.DataTypes;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.elasticsearch.xpack.eql.parser.AbstractBuilder.unquoteString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.nullValue;
+
+public class ExpressionTests extends ESTestCase {
+
+    private final EqlParser parser = new EqlParser();
+
+    public Expression expr(String source) {
+        return parser.createExpression(source);
+    }
+
+
+    public void testStrings() throws Exception {
+        assertEquals("hello\"world", unquoteString("'hello\"world'"));
+        assertEquals("hello'world", unquoteString("\"hello'world\""));
+        assertEquals("hello\nworld", unquoteString("'hello\\nworld'"));
+        assertEquals("hello\\\nworld", unquoteString("'hello\\\\\\nworld'"));
+        assertEquals("hello\\\"world", unquoteString("'hello\\\\\\\"world'"));
+
+        // test for unescaped strings: ?"...." or ?'....'
+        assertEquals("hello\"world", unquoteString("?'hello\"world'"));
+        assertEquals("hello\\\"world", unquoteString("?'hello\\\"world'"));
+        assertEquals("hello'world", unquoteString("?\"hello'world\""));
+        assertEquals("hello\\nworld", unquoteString("?'hello\\nworld'"));
+        assertEquals("hello\\\\nworld", unquoteString("?'hello\\\\nworld'"));
+        assertEquals("hello\\\\\\nworld", unquoteString("?'hello\\\\\\nworld'"));
+        assertEquals("hello\\\\\\\"world", unquoteString("?'hello\\\\\\\"world'"));
+    }
+
+    public void testLiterals() {
+        assertEquals(Literal.TRUE, expr("true"));
+        assertEquals(Literal.FALSE, expr("false"));
+        assertEquals(Literal.NULL, expr("null"));
+    }
+
+    public void testSingleQuotedString() {
+        // "hello \" world"
+        Expression parsed = expr("'hello \\' world!'");
+        Expression expected = new Literal(null, "hello ' world!", DataTypes.KEYWORD);
+        assertEquals(expected, parsed);
+    }
+
+    public void testDoubleQuotedString() {
+        // "hello \" world"
+        Expression parsed = expr("\"hello \\\" world!\"");
+        Expression expected = new Literal(null, "hello \" world!", DataTypes.KEYWORD);
+        assertEquals(expected, parsed);
+    }
+
+    public void testSingleQuotedUnescapedString() {
+        // "hello \" world"
+        Expression parsed = expr("?'hello \\' world!'");
+        Expression expected = new Literal(null, "hello \\' world!", DataTypes.KEYWORD);
+        assertEquals(expected, parsed);
+    }
+
+    public void testDoubleQuotedUnescapedString() {
+        // "hello \" world"
+        Expression parsed = expr("?\"hello \\\" world!\"");
+        Expression expected = new Literal(null, "hello \\\" world!", DataTypes.KEYWORD);
+        assertEquals(expected, parsed);
+    }
+
+    public void testNumbers() {
+        assertEquals(new Literal(null, 8589934592L, DataTypes.LONG), expr("8589934592"));
+        assertEquals(new Literal(null, 5, DataTypes.INTEGER), expr("5"));
+        assertEquals(new Literal(null, 5e14, DataTypes.DOUBLE), expr("5e14"));
+        assertEquals(new Literal(null, 5.2, DataTypes.DOUBLE), expr("5.2"));
+
+        Expression parsed = expr("-5.2");
+        Expression expected = new Neg(null, new Literal(null, 5.2, DataTypes.DOUBLE));
+        assertEquals(expected, parsed);
+    }
+
+    public void testBackQuotedAttribute() {
+        String quote = "`";
+        String qualifier = "table";
+        String name = "@timestamp";
+        Expression exp = expr(quote + qualifier + quote + "." + quote + name + quote);
+        assertThat(exp, instanceOf(UnresolvedAttribute.class));
+        UnresolvedAttribute ua = (UnresolvedAttribute) exp;
+        assertThat(ua.name(), equalTo(qualifier + "." + name));
+        assertThat(ua.qualifiedName(), equalTo(qualifier + "." + name));
+        assertThat(ua.qualifier(), is(nullValue()));
+    }
+
+    public void testFunctions() {
+        List<Expression> arguments = Arrays.asList(
+            new UnresolvedAttribute(null, "some.field"),
+            new Literal(null, "test string", DataTypes.KEYWORD)
+        );
+        UnresolvedFunction.ResolutionType resolutionType = UnresolvedFunction.ResolutionType.STANDARD;
+        Expression expected = new UnresolvedFunction(null, "concat", resolutionType, arguments);
+
+        assertEquals(expected, expr("concat(some.field, 'test string')"));
+    }
+
+    public void testComparison() {
+        String fieldText = "field";
+        String valueText = "2.0";
+
+        Expression field = expr(fieldText);
+        Expression value = expr(valueText);
+
+        assertEquals(new Equals(null, field, value), expr(fieldText + "==" + valueText));
+        assertEquals(new NotEquals(null, field, value), expr(fieldText + "!=" + valueText));
+        assertEquals(new LessThanOrEqual(null, field, value), expr(fieldText + "<=" + valueText));
+        assertEquals(new GreaterThanOrEqual(null, field, value), expr(fieldText + ">=" + valueText));
+        assertEquals(new GreaterThan(null, field, value), expr(fieldText + ">" + valueText));
+        assertEquals(new LessThan(null, field, value), expr(fieldText + "<" + valueText));
+    }
+
+    public void testBoolean() {
+        String leftText = "process_name == 'net.exe'";
+        String rightText = "command_line == '* localgroup*'";
+
+        Expression lhs = expr(leftText);
+        Expression rhs = expr(rightText);
+
+        Expression booleanAnd = expr(leftText + " and " + rightText);
+        assertEquals(new And(null, lhs, rhs), booleanAnd);
+
+        Expression booleanOr = expr(leftText + " or " + rightText);
+        assertEquals(new Or(null, lhs, rhs), booleanOr);
+    }
+
+    public void testInSet() {
+        assertEquals(
+            expr("name in ('net.exe')"),
+            expr("name == 'net.exe'")
+        );
+
+        assertEquals(
+            expr("name in ('net.exe', 'whoami.exe', 'hostname.exe')"),
+            expr("name == 'net.exe' or name == 'whoami.exe' or name == 'hostname.exe'")
+        );
+
+        assertEquals(
+            expr("name not in ('net.exe', 'whoami.exe', 'hostname.exe')"),
+            expr("not (name == 'net.exe' or name == 'whoami.exe' or name == 'hostname.exe')")
+        );
+    }
+}
diff --git a/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/parser/GrammarTests.java b/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/parser/GrammarTests.java
index bf3f2112a1eed..59a0ef86d709a 100644
--- a/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/parser/GrammarTests.java
+++ b/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/parser/GrammarTests.java
@@ -28,39 +28,12 @@
  */
 public class GrammarTests extends ESTestCase {
 
-    public void testStrings() throws Exception {
-        assertEquals("hello\"world", AstBuilder.unquoteString("'hello\"world'"));
-        assertEquals("hello'world", AstBuilder.unquoteString("\"hello'world\""));
-        assertEquals("hello\nworld", AstBuilder.unquoteString("'hello\\nworld'"));
-        assertEquals("hello\\\nworld", AstBuilder.unquoteString("'hello\\\\\\nworld'"));
-        assertEquals("hello\\\"world", AstBuilder.unquoteString("'hello\\\\\\\"world'"));
-
-        // test for unescaped strings: ?"...." or ?'....'
-        assertEquals("hello\"world", AstBuilder.unquoteString("?'hello\"world'"));
-        assertEquals("hello\\\"world", AstBuilder.unquoteString("?'hello\\\"world'"));
-        assertEquals("hello'world", AstBuilder.unquoteString("?\"hello'world\""));
-        assertEquals("hello\\nworld", AstBuilder.unquoteString("?'hello\\nworld'"));
-        assertEquals("hello\\\\nworld", AstBuilder.unquoteString("?'hello\\\\nworld'"));
-        assertEquals("hello\\\\\\nworld", AstBuilder.unquoteString("?'hello\\\\\\nworld'"));
-        assertEquals("hello\\\\\\\"world", AstBuilder.unquoteString("?'hello\\\\\\\"world'"));
-    }
-
     public void testSupportedQueries() throws Exception {
         EqlParser parser = new EqlParser();
         List<Tuple<String, Integer>> lines = readQueries("/queries-supported.eql");
         for (Tuple<String, Integer> line : lines) {
             String q = line.v1();
-
-            try {
-                parser.createStatement(q);
-            } catch (ParsingException pe) {
-                if (pe.getErrorMessage().startsWith("Does not know how to handle")) {
-                    // ignore for now
-                } else {
-                    throw new ParsingException(new Source(pe.getLineNumber() + line.v2() - 1, pe.getColumnNumber(), q),
-                        pe.getErrorMessage() + " inside statement <{}>", q);
-                }
-            }
+            parser.createStatement(q);
         }
     }
     public void testUnsupportedQueries() throws Exception {
diff --git a/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/parser/LogicalPlanTests.java b/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/parser/LogicalPlanTests.java
new file mode 100644
index 0000000000000..157fd9fa4738c
--- /dev/null
+++ b/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/parser/LogicalPlanTests.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+
+package org.elasticsearch.xpack.eql.parser;
+
+import org.elasticsearch.test.ESTestCase;
+import org.elasticsearch.xpack.ql.expression.Expression;
+import org.elasticsearch.xpack.ql.index.EsIndex;
+import org.elasticsearch.xpack.ql.plan.logical.EsRelation;
+import org.elasticsearch.xpack.ql.plan.logical.Filter;
+import org.elasticsearch.xpack.ql.plan.logical.LogicalPlan;
+import org.elasticsearch.xpack.ql.tree.Source;
+
+import static java.util.Collections.emptyMap;
+
+public class LogicalPlanTests extends ESTestCase {
+
+    private final EqlParser parser = new EqlParser();
+
+    public Expression expr(String source) {
+        return parser.createExpression(source);
+    }
+
+    public void testEventQuery() {
+        LogicalPlan fullQuery = parser.createStatement("process where process_name == 'net.exe'");
+        Expression fullExpression = expr("event.category == 'process' and process_name == 'net.exe'");
+        EsIndex esIndex = new EsIndex("<not-specified>", emptyMap());
+
+        assertEquals(fullQuery, new Filter(null, new EsRelation(Source.EMPTY, esIndex, false), fullExpression));
+    }
+}
diff --git a/x-pack/plugin/ql/src/main/java/org/elasticsearch/xpack/ql/index/EsIndex.java b/x-pack/plugin/ql/src/main/java/org/elasticsearch/xpack/ql/index/EsIndex.java
index 1481199cecf99..5250721d47fee 100644
--- a/x-pack/plugin/ql/src/main/java/org/elasticsearch/xpack/ql/index/EsIndex.java
+++ b/x-pack/plugin/ql/src/main/java/org/elasticsearch/xpack/ql/index/EsIndex.java
@@ -8,6 +8,7 @@
 import org.elasticsearch.xpack.ql.type.EsField;
 
 import java.util.Map;
+import java.util.Objects;
 
 public class EsIndex {
 
@@ -33,4 +34,23 @@ public Map<String, EsField> mapping() {
     public String toString() {
         return name;
     }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, mapping);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+
+        if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        }
+
+        EsIndex other = (EsIndex) obj;
+        return Objects.equals(name, other.name) && mapping == other.mapping;
+    }
 }