From fc5e1631f199849b91eba1fa0bdad8e12797476f Mon Sep 17 00:00:00 2001
From: Costin Leau <costin@users.noreply.github.com>
Date: Fri, 13 Apr 2018 18:16:47 +0300
Subject: [PATCH] SQL: generalize the use of ? for STRING
 (elastic/x-pack-elasticsearch#4359)

Improve grammar to allow use of ? as an alternative to STRING
through-out all commands
Add various parsing tests checking the ? usage for SYS commands

Original commit: elastic/x-pack-elasticsearch@d0d1feeb4caa92914b207b9a7f3699d9fb032246
---
 .../xpack/sql/jdbc/jdbc/JdbcDriver.java       |    7 +-
 .../xpack/sql/plugin/SqlTypedParamValue.java  |   17 +-
 plugin/sql/src/main/antlr/SqlBase.g4          |   24 +-
 .../xpack/sql/parser/AbstractBuilder.java     |    9 +-
 .../xpack/sql/parser/CommandBuilder.java      |    8 +-
 .../xpack/sql/parser/ExpressionBuilder.java   |   85 +-
 .../xpack/sql/parser/LogicalPlanBuilder.java  |    2 +
 .../xpack/sql/parser/SqlBaseBaseListener.java |   16 +-
 .../xpack/sql/parser/SqlBaseBaseVisitor.java  |    9 +-
 .../xpack/sql/parser/SqlBaseListener.java     |   18 +-
 .../xpack/sql/parser/SqlBaseParser.java       | 1601 +++++++++--------
 .../xpack/sql/parser/SqlBaseVisitor.java      |   10 +-
 .../xpack/sql/parser/SqlParser.java           |    6 +-
 .../xpack/sql/type/DataTypes.java             |    2 +-
 .../sql/parser/LikeEscapingParsingTests.java  |   13 +-
 ...atalogTests.java => SysCatalogsTests.java} |   22 +-
 .../command/sys/SysTableTypesTests.java       |   20 +-
 .../logical/command/sys/SysTablesTests.java   |   58 +-
 .../qa/sql/jdbc/DatabaseMetaDataTestCase.java |    2 +-
 .../setup_mock_metadata_get_table_type.sql    |   15 +
 20 files changed, 1051 insertions(+), 893 deletions(-)
 rename plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/{SysCatalogTests.java => SysCatalogsTests.java} (72%)
 create mode 100644 qa/sql/src/main/resources/setup_mock_metadata_get_table_type.sql

diff --git a/plugin/sql/jdbc/src/main/java/org/elasticsearch/xpack/sql/jdbc/jdbc/JdbcDriver.java b/plugin/sql/jdbc/src/main/java/org/elasticsearch/xpack/sql/jdbc/jdbc/JdbcDriver.java
index 8020f4dff30..3fdb002a0aa 100644
--- a/plugin/sql/jdbc/src/main/java/org/elasticsearch/xpack/sql/jdbc/jdbc/JdbcDriver.java
+++ b/plugin/sql/jdbc/src/main/java/org/elasticsearch/xpack/sql/jdbc/jdbc/JdbcDriver.java
@@ -5,9 +5,9 @@
  */
 package org.elasticsearch.xpack.sql.jdbc.jdbc;
 
+import org.elasticsearch.xpack.sql.client.shared.Version;
 import org.elasticsearch.xpack.sql.jdbc.JdbcSQLException;
 import org.elasticsearch.xpack.sql.jdbc.debug.Debug;
-import org.elasticsearch.xpack.sql.client.shared.Version;
 
 import java.io.PrintWriter;
 import java.sql.Connection;
@@ -16,11 +16,8 @@ import java.sql.DriverPropertyInfo;
 import java.sql.SQLException;
 import java.sql.SQLFeatureNotSupportedException;
 import java.util.Properties;
-import java.util.concurrent.TimeUnit;
 import java.util.logging.Logger;
 
-import static org.elasticsearch.xpack.sql.client.shared.ConnectionConfiguration.CONNECT_TIMEOUT;
-
 public class JdbcDriver implements java.sql.Driver {
 
     private static final JdbcDriver INSTANCE = new JdbcDriver();
@@ -67,6 +64,7 @@ public class JdbcDriver implements java.sql.Driver {
     //
     // Jdbc 4.0
     //
+    @Override
     public Connection connect(String url, Properties props) throws SQLException {
         if (url == null) {
             throw new JdbcSQLException("Non-null url required");
@@ -116,6 +114,7 @@ public class JdbcDriver implements java.sql.Driver {
     // Jdbc 4.1
     //
 
+    @Override
     public Logger getParentLogger() throws SQLFeatureNotSupportedException {
         throw new SQLFeatureNotSupportedException();
     }
diff --git a/plugin/sql/sql-proto/src/main/java/org/elasticsearch/xpack/sql/plugin/SqlTypedParamValue.java b/plugin/sql/sql-proto/src/main/java/org/elasticsearch/xpack/sql/plugin/SqlTypedParamValue.java
index 11350c8df50..ffde82fab34 100644
--- a/plugin/sql/sql-proto/src/main/java/org/elasticsearch/xpack/sql/plugin/SqlTypedParamValue.java
+++ b/plugin/sql/sql-proto/src/main/java/org/elasticsearch/xpack/sql/plugin/SqlTypedParamValue.java
@@ -13,7 +13,6 @@ import org.elasticsearch.common.xcontent.ConstructingObjectParser;
 import org.elasticsearch.common.xcontent.ObjectParser;
 import org.elasticsearch.common.xcontent.ToXContentObject;
 import org.elasticsearch.common.xcontent.XContentBuilder;
-import org.elasticsearch.common.xcontent.XContentHelper;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.common.xcontent.XContentParserUtils;
 import org.elasticsearch.xpack.sql.type.DataType;
@@ -75,8 +74,12 @@ public class SqlTypedParamValue implements ToXContentObject, Writeable {
 
     @Override
     public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
         SqlTypedParamValue that = (SqlTypedParamValue) o;
         return Objects.equals(value, that.value) &&
                 dataType == that.dataType;
@@ -84,7 +87,11 @@ public class SqlTypedParamValue implements ToXContentObject, Writeable {
 
     @Override
     public int hashCode() {
-
         return Objects.hash(value, dataType);
     }
-}
+
+    @Override
+    public String toString() {
+        return String.valueOf(value) + "[" + dataType + "]";
+    }
+}
\ No newline at end of file
diff --git a/plugin/sql/src/main/antlr/SqlBase.g4 b/plugin/sql/src/main/antlr/SqlBase.g4
index fffd16a7fec..ea0b7da161c 100644
--- a/plugin/sql/src/main/antlr/SqlBase.g4
+++ b/plugin/sql/src/main/antlr/SqlBase.g4
@@ -58,10 +58,10 @@ statement
     | SYS CATALOGS                                                                                        #sysCatalogs
     | SYS TABLES (CATALOG LIKE? clusterPattern=pattern)?
                  (LIKE? tablePattern=pattern)?
-                 (TYPE STRING (',' STRING)* )?                                                            #sysTables
-    | SYS COLUMNS (CATALOG cluster=(STRING | PARAM))?
+                 (TYPE string (',' string)* )?                                                            #sysTables
+    | SYS COLUMNS (CATALOG cluster=string)?
                   (TABLE LIKE? indexPattern=pattern)?
-                  (LIKE? columnPattern=pattern)?                                                   #sysColumns
+                  (LIKE? columnPattern=pattern)?                                                          #sysColumns
     | SYS TYPES                                                                                           #sysTypes
     | SYS TABLE TYPES                                                                                     #sysTableTypes  
     ;
@@ -158,9 +158,9 @@ expression
 booleanExpression
     : NOT booleanExpression                                                                 #logicalNot
     | EXISTS '(' query ')'                                                                  #exists
-    | QUERY '(' queryString=STRING (',' options=STRING)* ')'                                #stringQuery
-    | MATCH '(' singleField=qualifiedName ',' queryString=STRING (',' options=STRING)* ')'  #matchQuery
-    | MATCH '(' multiFields=STRING ',' queryString=STRING (',' options=STRING)* ')'         #multiMatchQuery
+    | QUERY '(' queryString=string (',' options=string)* ')'                                #stringQuery
+    | MATCH '(' singleField=qualifiedName ',' queryString=string (',' options=string)* ')'  #matchQuery
+    | MATCH '(' multiFields=string ',' queryString=string (',' options=string)* ')'         #multiMatchQuery
     | predicated                                                                            #booleanDefault
     | left=booleanExpression operator=AND right=booleanExpression                           #logicalBinary
     | left=booleanExpression operator=OR right=booleanExpression                            #logicalBinary
@@ -180,13 +180,12 @@ predicate
     | NOT? kind=IN '(' expression (',' expression)* ')'
     | NOT? kind=IN '(' query ')'
     | NOT? kind=LIKE pattern
-    | NOT? kind=RLIKE regex=STRING
+    | NOT? kind=RLIKE regex=string
     | IS NOT? kind=NULL
     ;
 
 pattern
-    : value=STRING (ESCAPE escape=STRING)?
-    | PARAM
+    : value=string (ESCAPE escape=string)?
     ;
 
 valueExpression
@@ -216,7 +215,7 @@ constant
     | number                                                                                   #numericLiteral
     | booleanValue                                                                             #booleanLiteral
     | STRING+                                                                                  #stringLiteral
-    | PARAM                                                                                    #param
+    | PARAM                                                                                    #paramLiteral
     ;
 
 comparisonOperator
@@ -261,6 +260,11 @@ number
     | INTEGER_VALUE  #integerLiteral
     ;
 
+string
+    : PARAM
+    | STRING
+    ;
+
 // http://developer.mimer.se/validator/sql-reserved-words.tml
 nonReserved
     : ANALYZE | ANALYZED 
diff --git a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/AbstractBuilder.java b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/AbstractBuilder.java
index c1ee41c6712..480d22a9699 100644
--- a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/AbstractBuilder.java
+++ b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/AbstractBuilder.java
@@ -92,13 +92,6 @@ abstract class AbstractBuilder extends SqlBaseBaseVisitor<Object> {
         return node == null ? null : node.getText();
     }
 
-    /**
-     * Extracts the actual unescaped string (literal) value of a token.
-     */
-    static String string(Token token) {
-        return token == null ? null : unquoteString(token.getText());
-    }
-
     /**
      * Extracts the actual unescaped string (literal) value of a terminal node.
      */
@@ -115,4 +108,4 @@ abstract class AbstractBuilder extends SqlBaseBaseVisitor<Object> {
     public Object visitTerminal(TerminalNode node) {
         throw new ParsingException(source(node), "Does not know how to handle {}", node.getText());
     }
-}
+}
\ No newline at end of file
diff --git a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/CommandBuilder.java b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/CommandBuilder.java
index 5ef44220dec..ac34890c376 100644
--- a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/CommandBuilder.java
+++ b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/CommandBuilder.java
@@ -6,7 +6,6 @@
 package org.elasticsearch.xpack.sql.parser;
 
 import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.tree.TerminalNode;
 import org.elasticsearch.common.Booleans;
 import org.elasticsearch.xpack.sql.analysis.index.IndexResolver.IndexType;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.DebugContext;
@@ -15,6 +14,7 @@ import org.elasticsearch.xpack.sql.parser.SqlBaseParser.ShowColumnsContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.ShowFunctionsContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.ShowSchemasContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.ShowTablesContext;
+import org.elasticsearch.xpack.sql.parser.SqlBaseParser.StringContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.SysCatalogsContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.SysColumnsContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.SysTableTypesContext;
@@ -43,6 +43,7 @@ import java.util.Locale;
 import java.util.Map;
 
 abstract class CommandBuilder extends LogicalPlanBuilder {
+
     protected CommandBuilder(Map<Token, SqlTypedParamValue> params) {
         super(params);
     }
@@ -146,7 +147,7 @@ abstract class CommandBuilder extends LogicalPlanBuilder {
     @Override
     public SysTables visitSysTables(SysTablesContext ctx) {
         List<IndexType> types = new ArrayList<>();
-        for (TerminalNode string : ctx.STRING()) {
+        for (StringContext string : ctx.string()) {
             String value = string(string);
             if (value != null) {
                 IndexType type = IndexType.from(value);
@@ -163,7 +164,7 @@ abstract class CommandBuilder extends LogicalPlanBuilder {
     @Override
     public Object visitSysColumns(SysColumnsContext ctx) {
         Location loc = source(ctx);
-        return new SysColumns(loc, stringOrParam(ctx.cluster, loc), visitPattern(ctx.indexPattern), visitPattern(ctx.columnPattern));
+        return new SysColumns(loc, string(ctx.cluster), visitPattern(ctx.indexPattern), visitPattern(ctx.columnPattern));
     }
 
     @Override
@@ -171,6 +172,7 @@ abstract class CommandBuilder extends LogicalPlanBuilder {
         return new SysTypes(source(ctx));
     }
 
+    @Override
     public Object visitSysTableTypes(SysTableTypesContext ctx) {
         return new SysTableTypes(source(ctx));
     }
diff --git a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/ExpressionBuilder.java b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/ExpressionBuilder.java
index 9d47b26b86b..b14611f9f59 100644
--- a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/ExpressionBuilder.java
+++ b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/ExpressionBuilder.java
@@ -63,6 +63,7 @@ import org.elasticsearch.xpack.sql.parser.SqlBaseParser.MatchQueryContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.MultiMatchQueryContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.NullLiteralContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.OrderByContext;
+import org.elasticsearch.xpack.sql.parser.SqlBaseParser.ParamLiteralContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.ParenthesizedExpressionContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.PatternContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.PredicateContext;
@@ -71,6 +72,7 @@ import org.elasticsearch.xpack.sql.parser.SqlBaseParser.PrimitiveDataTypeContext
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.SelectExpressionContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.SingleExpressionContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.StarContext;
+import org.elasticsearch.xpack.sql.parser.SqlBaseParser.StringContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.StringLiteralContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.StringQueryContext;
 import org.elasticsearch.xpack.sql.parser.SqlBaseParser.SubqueryExpressionContext;
@@ -88,14 +90,10 @@ import static java.util.Collections.singletonList;
 import static org.elasticsearch.xpack.sql.type.DataTypeConversion.conversionFor;
 
 abstract class ExpressionBuilder extends IdentifierBuilder {
+
     private final Map<Token, SqlTypedParamValue> params;
 
-    /**
-     * ExpressionBuilder constructor
-     *
-     * @param params   a map between '?' tokens that represent parameters and the actual parameter values
-     */
-    protected ExpressionBuilder(Map<Token, SqlTypedParamValue> params) {
+    ExpressionBuilder(Map<Token, SqlTypedParamValue> params) {
         this.params = params;
     }
 
@@ -215,11 +213,6 @@ abstract class ExpressionBuilder extends IdentifierBuilder {
             return null;
         }
 
-        if (ctx.PARAM() != null) {
-            Object pattern = paramValue(ctx.PARAM().getSymbol(), source(ctx));
-            return new LikePattern(source(ctx), pattern.toString(), (char) 0);
-        }
-
         String pattern = string(ctx.value);
         int pos = pattern.indexOf('*');
         if (pos >= 0) {
@@ -452,16 +445,21 @@ abstract class ExpressionBuilder extends IdentifierBuilder {
     }
 
     @Override
-    public Object visitParam(SqlBaseParser.ParamContext ctx) {
-        Token token = ctx.PARAM().getSymbol();
-        return paramValue(token, source(ctx));
+    public Object visitDecimalLiteral(DecimalLiteralContext ctx) {
+        return new Literal(source(ctx), new BigDecimal(ctx.getText()).doubleValue(), DataType.DOUBLE);
     }
 
-    private Object paramValue(Token token, Location loc) {
-        if (params.containsKey(token) == false) {
-            throw new ParsingException(loc, "Unexpected parameter");
-        }
-        SqlTypedParamValue param = params.get(token);
+    @Override
+    public Object visitIntegerLiteral(IntegerLiteralContext ctx) {
+        BigDecimal bigD = new BigDecimal(ctx.getText());
+        // TODO: this can be improved to use the smallest type available
+        return new Literal(source(ctx), bigD.longValueExact(), DataType.INTEGER);
+    }
+
+    @Override
+    public Object visitParamLiteral(ParamLiteralContext ctx) {
+        SqlTypedParamValue param = param(ctx.PARAM());
+        Location loc = source(ctx);
         if (param.value == null) {
             // no conversion is required for null values
             return new Literal(loc, null, param.dataType);
@@ -470,8 +468,8 @@ abstract class ExpressionBuilder extends IdentifierBuilder {
         try {
             sourceType = DataTypes.fromJava(param.value);
         } catch (SqlIllegalArgumentException ex) {
-            throw new ParsingException(ex, loc, "Unexpected actual parameter type [{}] for type [{}]",
-                    param.value.getClass().getName(), param.dataType);
+            throw new ParsingException(ex, loc, "Unexpected actual parameter type [{}] for type [{}]", param.value.getClass().getName(),
+                    param.dataType);
         }
         if (sourceType == param.dataType) {
             // no conversion is required if the value is already have correct type
@@ -485,32 +483,37 @@ abstract class ExpressionBuilder extends IdentifierBuilder {
         }
     }
 
+    @Override
+    public String visitString(StringContext ctx) {
+        return string(ctx);
+    }
+
     /**
-     * Extracts the actual unescaped string (literal) value of a token or a parameter value
+     * Extracts the string (either as unescaped literal) or parameter.
      */
-    public String stringOrParam(Token token, Location loc) {
-        if (token == null) {
+    String string(StringContext ctx) {
+        if (ctx == null) {
             return null;
         }
-        if (token.getType() == SqlBaseLexer.PARAM) {
-            if (params.containsKey(token) == false) {
-                throw new ParsingException(loc, "Unexpected parameter");
-            }
-            SqlTypedParamValue param = params.get(token);
-            return param.value == null ? null : param.value.toString();
+        SqlTypedParamValue param = param(ctx.PARAM());
+        if (param != null) {
+            return param.value != null ? param.value.toString() : null;
+        } else {
+            return unquoteString(ctx.getText());
         }
-        return unquoteString(token.getText());
     }
 
-    @Override
-    public Object visitDecimalLiteral(DecimalLiteralContext ctx) {
-        return new Literal(source(ctx), new BigDecimal(ctx.getText()).doubleValue(), DataType.DOUBLE);
-    }
+    private SqlTypedParamValue param(TerminalNode node) {
+        if (node == null) {
+            return null;
+        }
 
-    @Override
-    public Object visitIntegerLiteral(IntegerLiteralContext ctx) {
-        BigDecimal bigD = new BigDecimal(ctx.getText());
-        // TODO: this can be improved to use the smallest type available
-        return new Literal(source(ctx), bigD.longValueExact(), DataType.INTEGER);
+        Token token = node.getSymbol();
+
+        if (params.containsKey(token) == false) {
+            throw new ParsingException(source(node), "Unexpected parameter");
+        }
+
+        return params.get(token);
     }
-}
+}
\ No newline at end of file
diff --git a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/LogicalPlanBuilder.java b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/LogicalPlanBuilder.java
index 9cc6b79f3c3..f41fce16027 100644
--- a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/LogicalPlanBuilder.java
+++ b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/LogicalPlanBuilder.java
@@ -53,6 +53,7 @@ import static java.util.Collections.emptyList;
 import static java.util.stream.Collectors.toList;
 
 abstract class LogicalPlanBuilder extends ExpressionBuilder {
+
     protected LogicalPlanBuilder(Map<Token, SqlTypedParamValue> params) {
         super(params);
     }
@@ -80,6 +81,7 @@ abstract class LogicalPlanBuilder extends ExpressionBuilder {
         return new SubQueryAlias(source(ctx), plan(ctx.queryNoWith()), ctx.name.getText());
     }
 
+    @Override
     public LogicalPlan visitQueryNoWith(QueryNoWithContext ctx) {
         LogicalPlan plan = plan(ctx.queryTerm());
 
diff --git a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseBaseListener.java b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseBaseListener.java
index d66774e2f43..4e80e8db9bb 100644
--- a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseBaseListener.java
+++ b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseBaseListener.java
@@ -765,13 +765,13 @@ class SqlBaseBaseListener implements SqlBaseListener {
    *
    * <p>The default implementation does nothing.</p>
    */
-  @Override public void enterParam(SqlBaseParser.ParamContext ctx) { }
+  @Override public void enterParamLiteral(SqlBaseParser.ParamLiteralContext ctx) { }
   /**
    * {@inheritDoc}
    *
    * <p>The default implementation does nothing.</p>
    */
-  @Override public void exitParam(SqlBaseParser.ParamContext ctx) { }
+  @Override public void exitParamLiteral(SqlBaseParser.ParamLiteralContext ctx) { }
   /**
    * {@inheritDoc}
    *
@@ -916,6 +916,18 @@ class SqlBaseBaseListener implements SqlBaseListener {
    * <p>The default implementation does nothing.</p>
    */
   @Override public void exitIntegerLiteral(SqlBaseParser.IntegerLiteralContext ctx) { }
+  /**
+   * {@inheritDoc}
+   *
+   * <p>The default implementation does nothing.</p>
+   */
+  @Override public void enterString(SqlBaseParser.StringContext ctx) { }
+  /**
+   * {@inheritDoc}
+   *
+   * <p>The default implementation does nothing.</p>
+   */
+  @Override public void exitString(SqlBaseParser.StringContext ctx) { }
   /**
    * {@inheritDoc}
    *
diff --git a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseBaseVisitor.java b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseBaseVisitor.java
index fe9a41e2494..1adb0a423c7 100644
--- a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseBaseVisitor.java
+++ b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseBaseVisitor.java
@@ -456,7 +456,7 @@ class SqlBaseBaseVisitor<T> extends AbstractParseTreeVisitor<T> implements SqlBa
    * <p>The default implementation returns the result of calling
    * {@link #visitChildren} on {@code ctx}.</p>
    */
-  @Override public T visitParam(SqlBaseParser.ParamContext ctx) { return visitChildren(ctx); }
+  @Override public T visitParamLiteral(SqlBaseParser.ParamLiteralContext ctx) { return visitChildren(ctx); }
   /**
    * {@inheritDoc}
    *
@@ -541,6 +541,13 @@ class SqlBaseBaseVisitor<T> extends AbstractParseTreeVisitor<T> implements SqlBa
    * {@link #visitChildren} on {@code ctx}.</p>
    */
   @Override public T visitIntegerLiteral(SqlBaseParser.IntegerLiteralContext ctx) { return visitChildren(ctx); }
+  /**
+   * {@inheritDoc}
+   *
+   * <p>The default implementation returns the result of calling
+   * {@link #visitChildren} on {@code ctx}.</p>
+   */
+  @Override public T visitString(SqlBaseParser.StringContext ctx) { return visitChildren(ctx); }
   /**
    * {@inheritDoc}
    *
diff --git a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseListener.java b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseListener.java
index 52306f7d716..48f6eb4a7c8 100644
--- a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseListener.java
+++ b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseListener.java
@@ -719,17 +719,17 @@ interface SqlBaseListener extends ParseTreeListener {
    */
   void exitStringLiteral(SqlBaseParser.StringLiteralContext ctx);
   /**
-   * Enter a parse tree produced by the {@code param}
+   * Enter a parse tree produced by the {@code paramLiteral}
    * labeled alternative in {@link SqlBaseParser#constant}.
    * @param ctx the parse tree
    */
-  void enterParam(SqlBaseParser.ParamContext ctx);
+  void enterParamLiteral(SqlBaseParser.ParamLiteralContext ctx);
   /**
-   * Exit a parse tree produced by the {@code param}
+   * Exit a parse tree produced by the {@code paramLiteral}
    * labeled alternative in {@link SqlBaseParser#constant}.
    * @param ctx the parse tree
    */
-  void exitParam(SqlBaseParser.ParamContext ctx);
+  void exitParamLiteral(SqlBaseParser.ParamLiteralContext ctx);
   /**
    * Enter a parse tree produced by {@link SqlBaseParser#comparisonOperator}.
    * @param ctx the parse tree
@@ -864,6 +864,16 @@ interface SqlBaseListener extends ParseTreeListener {
    * @param ctx the parse tree
    */
   void exitIntegerLiteral(SqlBaseParser.IntegerLiteralContext ctx);
+  /**
+   * Enter a parse tree produced by {@link SqlBaseParser#string}.
+   * @param ctx the parse tree
+   */
+  void enterString(SqlBaseParser.StringContext ctx);
+  /**
+   * Exit a parse tree produced by {@link SqlBaseParser#string}.
+   * @param ctx the parse tree
+   */
+  void exitString(SqlBaseParser.StringContext ctx);
   /**
    * Enter a parse tree produced by {@link SqlBaseParser#nonReserved}.
    * @param ctx the parse tree
diff --git a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseParser.java b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseParser.java
index 4f2d11f69b3..e9d7ff26399 100644
--- a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseParser.java
+++ b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseParser.java
@@ -48,7 +48,7 @@ class SqlBaseParser extends Parser {
     RULE_constant = 27, RULE_comparisonOperator = 28, RULE_booleanValue = 29, 
     RULE_dataType = 30, RULE_qualifiedName = 31, RULE_identifier = 32, RULE_tableIdentifier = 33, 
     RULE_quoteIdentifier = 34, RULE_unquoteIdentifier = 35, RULE_number = 36, 
-    RULE_nonReserved = 37;
+    RULE_string = 37, RULE_nonReserved = 38;
   public static final String[] ruleNames = {
     "singleStatement", "singleExpression", "statement", "query", "queryNoWith", 
     "queryTerm", "orderBy", "querySpecification", "fromClause", "groupBy", 
@@ -57,7 +57,7 @@ class SqlBaseParser extends Parser {
     "relationPrimary", "expression", "booleanExpression", "predicated", "predicate", 
     "pattern", "valueExpression", "primaryExpression", "constant", "comparisonOperator", 
     "booleanValue", "dataType", "qualifiedName", "identifier", "tableIdentifier", 
-    "quoteIdentifier", "unquoteIdentifier", "number", "nonReserved"
+    "quoteIdentifier", "unquoteIdentifier", "number", "string", "nonReserved"
   };
 
   private static final String[] _LITERAL_NAMES = {
@@ -169,9 +169,9 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(76);
+      setState(78);
       statement();
-      setState(77);
+      setState(79);
       match(EOF);
       }
     }
@@ -216,9 +216,9 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(79);
+      setState(81);
       expression();
-      setState(80);
+      setState(82);
       match(EOF);
       }
     }
@@ -336,21 +336,22 @@ class SqlBaseParser extends Parser {
     }
   }
   public static class SysColumnsContext extends StatementContext {
-    public Token cluster;
+    public StringContext cluster;
     public PatternContext indexPattern;
     public PatternContext columnPattern;
     public TerminalNode SYS() { return getToken(SqlBaseParser.SYS, 0); }
     public TerminalNode COLUMNS() { return getToken(SqlBaseParser.COLUMNS, 0); }
     public TerminalNode CATALOG() { return getToken(SqlBaseParser.CATALOG, 0); }
     public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
+    public StringContext string() {
+      return getRuleContext(StringContext.class,0);
+    }
     public List<PatternContext> pattern() {
       return getRuleContexts(PatternContext.class);
     }
     public PatternContext pattern(int i) {
       return getRuleContext(PatternContext.class,i);
     }
-    public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
-    public TerminalNode PARAM() { return getToken(SqlBaseParser.PARAM, 0); }
     public List<TerminalNode> LIKE() { return getTokens(SqlBaseParser.LIKE); }
     public TerminalNode LIKE(int i) {
       return getToken(SqlBaseParser.LIKE, i);
@@ -479,9 +480,11 @@ class SqlBaseParser extends Parser {
     public TerminalNode TABLES() { return getToken(SqlBaseParser.TABLES, 0); }
     public TerminalNode CATALOG() { return getToken(SqlBaseParser.CATALOG, 0); }
     public TerminalNode TYPE() { return getToken(SqlBaseParser.TYPE, 0); }
-    public List<TerminalNode> STRING() { return getTokens(SqlBaseParser.STRING); }
-    public TerminalNode STRING(int i) {
-      return getToken(SqlBaseParser.STRING, i);
+    public List<StringContext> string() {
+      return getRuleContexts(StringContext.class);
+    }
+    public StringContext string(int i) {
+      return getRuleContext(StringContext.class,i);
     }
     public List<PatternContext> pattern() {
       return getRuleContexts(PatternContext.class);
@@ -601,14 +604,14 @@ class SqlBaseParser extends Parser {
     enterRule(_localctx, 4, RULE_statement);
     int _la;
     try {
-      setState(191);
+      setState(193);
       _errHandler.sync(this);
       switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
       case 1:
         _localctx = new StatementDefaultContext(_localctx);
         enterOuterAlt(_localctx, 1);
         {
-        setState(82);
+        setState(84);
         query();
         }
         break;
@@ -616,27 +619,27 @@ class SqlBaseParser extends Parser {
         _localctx = new ExplainContext(_localctx);
         enterOuterAlt(_localctx, 2);
         {
-        setState(83);
+        setState(85);
         match(EXPLAIN);
-        setState(97);
+        setState(99);
         _errHandler.sync(this);
         switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
         case 1:
           {
-          setState(84);
+          setState(86);
           match(T__0);
-          setState(93);
+          setState(95);
           _errHandler.sync(this);
           _la = _input.LA(1);
           while (((((_la - 28)) & ~0x3f) == 0 && ((1L << (_la - 28)) & ((1L << (FORMAT - 28)) | (1L << (PLAN - 28)) | (1L << (VERIFY - 28)))) != 0)) {
             {
-            setState(91);
+            setState(93);
             switch (_input.LA(1)) {
             case PLAN:
               {
-              setState(85);
+              setState(87);
               match(PLAN);
-              setState(86);
+              setState(88);
               ((ExplainContext)_localctx).type = _input.LT(1);
               _la = _input.LA(1);
               if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ALL) | (1L << ANALYZED) | (1L << EXECUTABLE) | (1L << MAPPED) | (1L << OPTIMIZED) | (1L << PARSED))) != 0)) ) {
@@ -648,9 +651,9 @@ class SqlBaseParser extends Parser {
               break;
             case FORMAT:
               {
-              setState(87);
+              setState(89);
               match(FORMAT);
-              setState(88);
+              setState(90);
               ((ExplainContext)_localctx).format = _input.LT(1);
               _la = _input.LA(1);
               if ( !(_la==GRAPHVIZ || _la==TEXT) ) {
@@ -662,9 +665,9 @@ class SqlBaseParser extends Parser {
               break;
             case VERIFY:
               {
-              setState(89);
+              setState(91);
               match(VERIFY);
-              setState(90);
+              setState(92);
               ((ExplainContext)_localctx).verify = booleanValue();
               }
               break;
@@ -672,16 +675,16 @@ class SqlBaseParser extends Parser {
               throw new NoViableAltException(this);
             }
             }
-            setState(95);
+            setState(97);
             _errHandler.sync(this);
             _la = _input.LA(1);
           }
-          setState(96);
+          setState(98);
           match(T__1);
           }
           break;
         }
-        setState(99);
+        setState(101);
         statement();
         }
         break;
@@ -689,27 +692,27 @@ class SqlBaseParser extends Parser {
         _localctx = new DebugContext(_localctx);
         enterOuterAlt(_localctx, 3);
         {
-        setState(100);
+        setState(102);
         match(DEBUG);
-        setState(112);
+        setState(114);
         _errHandler.sync(this);
         switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
         case 1:
           {
-          setState(101);
+          setState(103);
           match(T__0);
-          setState(108);
+          setState(110);
           _errHandler.sync(this);
           _la = _input.LA(1);
           while (_la==FORMAT || _la==PLAN) {
             {
-            setState(106);
+            setState(108);
             switch (_input.LA(1)) {
             case PLAN:
               {
-              setState(102);
+              setState(104);
               match(PLAN);
-              setState(103);
+              setState(105);
               ((DebugContext)_localctx).type = _input.LT(1);
               _la = _input.LA(1);
               if ( !(_la==ANALYZED || _la==OPTIMIZED) ) {
@@ -721,9 +724,9 @@ class SqlBaseParser extends Parser {
               break;
             case FORMAT:
               {
-              setState(104);
+              setState(106);
               match(FORMAT);
-              setState(105);
+              setState(107);
               ((DebugContext)_localctx).format = _input.LT(1);
               _la = _input.LA(1);
               if ( !(_la==GRAPHVIZ || _la==TEXT) ) {
@@ -737,16 +740,16 @@ class SqlBaseParser extends Parser {
               throw new NoViableAltException(this);
             }
             }
-            setState(110);
+            setState(112);
             _errHandler.sync(this);
             _la = _input.LA(1);
           }
-          setState(111);
+          setState(113);
           match(T__1);
           }
           break;
         }
-        setState(114);
+        setState(116);
         statement();
         }
         break;
@@ -754,24 +757,24 @@ class SqlBaseParser extends Parser {
         _localctx = new ShowTablesContext(_localctx);
         enterOuterAlt(_localctx, 4);
         {
-        setState(115);
+        setState(117);
         match(SHOW);
-        setState(116);
+        setState(118);
         match(TABLES);
-        setState(121);
+        setState(123);
         _la = _input.LA(1);
         if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & ((1L << (LIKE - 40)) | (1L << (PARAM - 40)) | (1L << (STRING - 40)))) != 0)) {
           {
-          setState(118);
+          setState(120);
           _la = _input.LA(1);
           if (_la==LIKE) {
             {
-            setState(117);
+            setState(119);
             match(LIKE);
             }
           }
 
-          setState(120);
+          setState(122);
           pattern();
           }
         }
@@ -782,28 +785,13 @@ class SqlBaseParser extends Parser {
         _localctx = new ShowColumnsContext(_localctx);
         enterOuterAlt(_localctx, 5);
         {
-        setState(123);
-        match(SHOW);
-        setState(124);
-        match(COLUMNS);
         setState(125);
-        _la = _input.LA(1);
-        if ( !(_la==FROM || _la==IN) ) {
-        _errHandler.recoverInline(this);
-        } else {
-          consume();
-        }
+        match(SHOW);
         setState(126);
-        tableIdentifier();
-        }
-        break;
-      case 6:
-        _localctx = new ShowColumnsContext(_localctx);
-        enterOuterAlt(_localctx, 6);
-        {
+        match(COLUMNS);
         setState(127);
         _la = _input.LA(1);
-        if ( !(_la==DESC || _la==DESCRIBE) ) {
+        if ( !(_la==FROM || _la==IN) ) {
         _errHandler.recoverInline(this);
         } else {
           consume();
@@ -812,28 +800,43 @@ class SqlBaseParser extends Parser {
         tableIdentifier();
         }
         break;
+      case 6:
+        _localctx = new ShowColumnsContext(_localctx);
+        enterOuterAlt(_localctx, 6);
+        {
+        setState(129);
+        _la = _input.LA(1);
+        if ( !(_la==DESC || _la==DESCRIBE) ) {
+        _errHandler.recoverInline(this);
+        } else {
+          consume();
+        }
+        setState(130);
+        tableIdentifier();
+        }
+        break;
       case 7:
         _localctx = new ShowFunctionsContext(_localctx);
         enterOuterAlt(_localctx, 7);
         {
-        setState(129);
+        setState(131);
         match(SHOW);
-        setState(130);
+        setState(132);
         match(FUNCTIONS);
-        setState(135);
+        setState(137);
         _la = _input.LA(1);
         if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & ((1L << (LIKE - 40)) | (1L << (PARAM - 40)) | (1L << (STRING - 40)))) != 0)) {
           {
-          setState(132);
+          setState(134);
           _la = _input.LA(1);
           if (_la==LIKE) {
             {
-            setState(131);
+            setState(133);
             match(LIKE);
             }
           }
 
-          setState(134);
+          setState(136);
           pattern();
           }
         }
@@ -844,9 +847,9 @@ class SqlBaseParser extends Parser {
         _localctx = new ShowSchemasContext(_localctx);
         enterOuterAlt(_localctx, 8);
         {
-        setState(137);
+        setState(139);
         match(SHOW);
-        setState(138);
+        setState(140);
         match(SCHEMAS);
         }
         break;
@@ -854,9 +857,9 @@ class SqlBaseParser extends Parser {
         _localctx = new SysCatalogsContext(_localctx);
         enterOuterAlt(_localctx, 9);
         {
-        setState(139);
+        setState(141);
         match(SYS);
-        setState(140);
+        setState(142);
         match(CATALOGS);
         }
         break;
@@ -864,69 +867,69 @@ class SqlBaseParser extends Parser {
         _localctx = new SysTablesContext(_localctx);
         enterOuterAlt(_localctx, 10);
         {
-        setState(141);
+        setState(143);
         match(SYS);
-        setState(142);
+        setState(144);
         match(TABLES);
-        setState(148);
+        setState(150);
         _la = _input.LA(1);
         if (_la==CATALOG) {
           {
-          setState(143);
-          match(CATALOG);
           setState(145);
+          match(CATALOG);
+          setState(147);
           _la = _input.LA(1);
           if (_la==LIKE) {
             {
-            setState(144);
+            setState(146);
             match(LIKE);
             }
           }
 
-          setState(147);
+          setState(149);
           ((SysTablesContext)_localctx).clusterPattern = pattern();
           }
         }
 
-        setState(154);
+        setState(156);
         _la = _input.LA(1);
         if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & ((1L << (LIKE - 40)) | (1L << (PARAM - 40)) | (1L << (STRING - 40)))) != 0)) {
           {
-          setState(151);
+          setState(153);
           _la = _input.LA(1);
           if (_la==LIKE) {
             {
-            setState(150);
+            setState(152);
             match(LIKE);
             }
           }
 
-          setState(153);
+          setState(155);
           ((SysTablesContext)_localctx).tablePattern = pattern();
           }
         }
 
-        setState(165);
+        setState(167);
         _la = _input.LA(1);
         if (_la==TYPE) {
           {
-          setState(156);
+          setState(158);
           match(TYPE);
-          setState(157);
-          match(STRING);
-          setState(162);
+          setState(159);
+          string();
+          setState(164);
           _errHandler.sync(this);
           _la = _input.LA(1);
           while (_la==T__2) {
             {
             {
-            setState(158);
+            setState(160);
             match(T__2);
-            setState(159);
-            match(STRING);
+            setState(161);
+            string();
             }
             }
-            setState(164);
+            setState(166);
             _errHandler.sync(this);
             _la = _input.LA(1);
           }
@@ -939,61 +942,55 @@ class SqlBaseParser extends Parser {
         _localctx = new SysColumnsContext(_localctx);
         enterOuterAlt(_localctx, 11);
         {
-        setState(167);
+        setState(169);
         match(SYS);
-        setState(168);
+        setState(170);
         match(COLUMNS);
-        setState(171);
+        setState(173);
         _la = _input.LA(1);
         if (_la==CATALOG) {
           {
-          setState(169);
+          setState(171);
           match(CATALOG);
-          setState(170);
-          ((SysColumnsContext)_localctx).cluster = _input.LT(1);
-          _la = _input.LA(1);
-          if ( !(_la==PARAM || _la==STRING) ) {
-            ((SysColumnsContext)_localctx).cluster = (Token)_errHandler.recoverInline(this);
-          } else {
-            consume();
-          }
+          setState(172);
+          ((SysColumnsContext)_localctx).cluster = string();
           }
         }
 
-        setState(178);
+        setState(180);
         _la = _input.LA(1);
         if (_la==TABLE) {
           {
-          setState(173);
-          match(TABLE);
           setState(175);
+          match(TABLE);
+          setState(177);
           _la = _input.LA(1);
           if (_la==LIKE) {
             {
-            setState(174);
+            setState(176);
             match(LIKE);
             }
           }
 
-          setState(177);
+          setState(179);
           ((SysColumnsContext)_localctx).indexPattern = pattern();
           }
         }
 
-        setState(184);
+        setState(186);
         _la = _input.LA(1);
         if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & ((1L << (LIKE - 40)) | (1L << (PARAM - 40)) | (1L << (STRING - 40)))) != 0)) {
           {
-          setState(181);
+          setState(183);
           _la = _input.LA(1);
           if (_la==LIKE) {
             {
-            setState(180);
+            setState(182);
             match(LIKE);
             }
           }
 
-          setState(183);
+          setState(185);
           ((SysColumnsContext)_localctx).columnPattern = pattern();
           }
         }
@@ -1004,9 +1001,9 @@ class SqlBaseParser extends Parser {
         _localctx = new SysTypesContext(_localctx);
         enterOuterAlt(_localctx, 12);
         {
-        setState(186);
+        setState(188);
         match(SYS);
-        setState(187);
+        setState(189);
         match(TYPES);
         }
         break;
@@ -1014,11 +1011,11 @@ class SqlBaseParser extends Parser {
         _localctx = new SysTableTypesContext(_localctx);
         enterOuterAlt(_localctx, 13);
         {
-        setState(188);
-        match(SYS);
-        setState(189);
-        match(TABLE);
         setState(190);
+        match(SYS);
+        setState(191);
+        match(TABLE);
+        setState(192);
         match(TYPES);
         }
         break;
@@ -1072,34 +1069,34 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(202);
+      setState(204);
       _la = _input.LA(1);
       if (_la==WITH) {
         {
-        setState(193);
+        setState(195);
         match(WITH);
-        setState(194);
+        setState(196);
         namedQuery();
-        setState(199);
+        setState(201);
         _errHandler.sync(this);
         _la = _input.LA(1);
         while (_la==T__2) {
           {
           {
-          setState(195);
+          setState(197);
           match(T__2);
-          setState(196);
+          setState(198);
           namedQuery();
           }
           }
-          setState(201);
+          setState(203);
           _errHandler.sync(this);
           _la = _input.LA(1);
         }
         }
       }
 
-      setState(204);
+      setState(206);
       queryNoWith();
       }
     }
@@ -1156,44 +1153,44 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(206);
+      setState(208);
       queryTerm();
-      setState(217);
+      setState(219);
       _la = _input.LA(1);
       if (_la==ORDER) {
         {
-        setState(207);
-        match(ORDER);
-        setState(208);
-        match(BY);
         setState(209);
+        match(ORDER);
+        setState(210);
+        match(BY);
+        setState(211);
         orderBy();
-        setState(214);
+        setState(216);
         _errHandler.sync(this);
         _la = _input.LA(1);
         while (_la==T__2) {
           {
           {
-          setState(210);
+          setState(212);
           match(T__2);
-          setState(211);
+          setState(213);
           orderBy();
           }
           }
-          setState(216);
+          setState(218);
           _errHandler.sync(this);
           _la = _input.LA(1);
         }
         }
       }
 
-      setState(221);
+      setState(223);
       _la = _input.LA(1);
       if (_la==LIMIT) {
         {
-        setState(219);
+        setState(221);
         match(LIMIT);
-        setState(220);
+        setState(222);
         ((QueryNoWithContext)_localctx).limit = _input.LT(1);
         _la = _input.LA(1);
         if ( !(_la==ALL || _la==INTEGER_VALUE) ) {
@@ -1271,13 +1268,13 @@ class SqlBaseParser extends Parser {
     QueryTermContext _localctx = new QueryTermContext(_ctx, getState());
     enterRule(_localctx, 10, RULE_queryTerm);
     try {
-      setState(228);
+      setState(230);
       switch (_input.LA(1)) {
       case SELECT:
         _localctx = new QueryPrimaryDefaultContext(_localctx);
         enterOuterAlt(_localctx, 1);
         {
-        setState(223);
+        setState(225);
         querySpecification();
         }
         break;
@@ -1285,11 +1282,11 @@ class SqlBaseParser extends Parser {
         _localctx = new SubqueryContext(_localctx);
         enterOuterAlt(_localctx, 2);
         {
-        setState(224);
-        match(T__0);
-        setState(225);
-        queryNoWith();
         setState(226);
+        match(T__0);
+        setState(227);
+        queryNoWith();
+        setState(228);
         match(T__1);
         }
         break;
@@ -1341,13 +1338,13 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(230);
-      expression();
       setState(232);
+      expression();
+      setState(234);
       _la = _input.LA(1);
       if (_la==ASC || _la==DESC) {
         {
-        setState(231);
+        setState(233);
         ((OrderByContext)_localctx).ordering = _input.LT(1);
         _la = _input.LA(1);
         if ( !(_la==ASC || _la==DESC) ) {
@@ -1426,75 +1423,75 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(234);
-      match(SELECT);
       setState(236);
+      match(SELECT);
+      setState(238);
       _la = _input.LA(1);
       if (_la==ALL || _la==DISTINCT) {
         {
-        setState(235);
+        setState(237);
         setQuantifier();
         }
       }
 
-      setState(238);
+      setState(240);
       selectItem();
-      setState(243);
+      setState(245);
       _errHandler.sync(this);
       _la = _input.LA(1);
       while (_la==T__2) {
         {
         {
-        setState(239);
+        setState(241);
         match(T__2);
-        setState(240);
+        setState(242);
         selectItem();
         }
         }
-        setState(245);
+        setState(247);
         _errHandler.sync(this);
         _la = _input.LA(1);
       }
-      setState(247);
+      setState(249);
       _la = _input.LA(1);
       if (_la==FROM) {
         {
-        setState(246);
+        setState(248);
         fromClause();
         }
       }
 
-      setState(251);
+      setState(253);
       _la = _input.LA(1);
       if (_la==WHERE) {
         {
-        setState(249);
+        setState(251);
         match(WHERE);
-        setState(250);
+        setState(252);
         ((QuerySpecificationContext)_localctx).where = booleanExpression(0);
         }
       }
 
-      setState(256);
+      setState(258);
       _la = _input.LA(1);
       if (_la==GROUP) {
         {
-        setState(253);
-        match(GROUP);
-        setState(254);
-        match(BY);
         setState(255);
+        match(GROUP);
+        setState(256);
+        match(BY);
+        setState(257);
         groupBy();
         }
       }
 
-      setState(260);
+      setState(262);
       _la = _input.LA(1);
       if (_la==HAVING) {
         {
-        setState(258);
+        setState(260);
         match(HAVING);
-        setState(259);
+        setState(261);
         ((QuerySpecificationContext)_localctx).having = booleanExpression(0);
         }
       }
@@ -1546,23 +1543,23 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(262);
+      setState(264);
       match(FROM);
-      setState(263);
+      setState(265);
       relation();
-      setState(268);
+      setState(270);
       _errHandler.sync(this);
       _la = _input.LA(1);
       while (_la==T__2) {
         {
         {
-        setState(264);
+        setState(266);
         match(T__2);
-        setState(265);
+        setState(267);
         relation();
         }
         }
-        setState(270);
+        setState(272);
         _errHandler.sync(this);
         _la = _input.LA(1);
       }
@@ -1615,30 +1612,30 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(272);
+      setState(274);
       _la = _input.LA(1);
       if (_la==ALL || _la==DISTINCT) {
         {
-        setState(271);
+        setState(273);
         setQuantifier();
         }
       }
 
-      setState(274);
+      setState(276);
       groupingElement();
-      setState(279);
+      setState(281);
       _errHandler.sync(this);
       _la = _input.LA(1);
       while (_la==T__2) {
         {
         {
-        setState(275);
+        setState(277);
         match(T__2);
-        setState(276);
+        setState(278);
         groupingElement();
         }
         }
-        setState(281);
+        setState(283);
         _errHandler.sync(this);
         _la = _input.LA(1);
       }
@@ -1693,7 +1690,7 @@ class SqlBaseParser extends Parser {
       _localctx = new SingleGroupingSetContext(_localctx);
       enterOuterAlt(_localctx, 1);
       {
-      setState(282);
+      setState(284);
       groupingExpressions();
       }
     }
@@ -1739,47 +1736,47 @@ class SqlBaseParser extends Parser {
     enterRule(_localctx, 22, RULE_groupingExpressions);
     int _la;
     try {
-      setState(297);
+      setState(299);
       _errHandler.sync(this);
       switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
       case 1:
         enterOuterAlt(_localctx, 1);
         {
-        setState(284);
+        setState(286);
         match(T__0);
-        setState(293);
+        setState(295);
         _la = _input.LA(1);
         if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << ANALYZE) | (1L << ANALYZED) | (1L << CAST) | (1L << CATALOGS) | (1L << COLUMNS) | (1L << DEBUG) | (1L << EXECUTABLE) | (1L << EXISTS) | (1L << EXPLAIN) | (1L << EXTRACT) | (1L << FALSE) | (1L << FORMAT) | (1L << FUNCTIONS) | (1L << GRAPHVIZ) | (1L << MAPPED) | (1L << MATCH) | (1L << NOT) | (1L << NULL) | (1L << OPTIMIZED) | (1L << PARSED) | (1L << PHYSICAL) | (1L << PLAN) | (1L << RLIKE) | (1L << QUERY) | (1L << SCHEMAS) | (1L << SHOW) | (1L << SYS) | (1L << TABLES))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TEXT - 64)) | (1L << (TRUE - 64)) | (1L << (TYPE - 64)) | (1L << (TYPES - 64)) | (1L << (VERIFY - 64)) | (1L << (PLUS - 64)) | (1L << (MINUS - 64)) | (1L << (ASTERISK - 64)) | (1L << (PARAM - 64)) | (1L << (STRING - 64)) | (1L << (INTEGER_VALUE - 64)) | (1L << (DECIMAL_VALUE - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (DIGIT_IDENTIFIER - 64)) | (1L << (QUOTED_IDENTIFIER - 64)) | (1L << (BACKQUOTED_IDENTIFIER - 64)))) != 0)) {
           {
-          setState(285);
+          setState(287);
           expression();
-          setState(290);
+          setState(292);
           _errHandler.sync(this);
           _la = _input.LA(1);
           while (_la==T__2) {
             {
             {
-            setState(286);
+            setState(288);
             match(T__2);
-            setState(287);
+            setState(289);
             expression();
             }
             }
-            setState(292);
+            setState(294);
             _errHandler.sync(this);
             _la = _input.LA(1);
           }
           }
         }
 
-        setState(295);
+        setState(297);
         match(T__1);
         }
         break;
       case 2:
         enterOuterAlt(_localctx, 2);
         {
-        setState(296);
+        setState(298);
         expression();
         }
         break;
@@ -1830,15 +1827,15 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(299);
-      ((NamedQueryContext)_localctx).name = identifier();
-      setState(300);
-      match(AS);
       setState(301);
-      match(T__0);
+      ((NamedQueryContext)_localctx).name = identifier();
       setState(302);
-      queryNoWith();
+      match(AS);
       setState(303);
+      match(T__0);
+      setState(304);
+      queryNoWith();
+      setState(305);
       match(T__1);
       }
     }
@@ -1882,7 +1879,7 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(305);
+      setState(307);
       _la = _input.LA(1);
       if ( !(_la==ALL || _la==DISTINCT) ) {
       _errHandler.recoverInline(this);
@@ -1945,22 +1942,22 @@ class SqlBaseParser extends Parser {
       _localctx = new SelectExpressionContext(_localctx);
       enterOuterAlt(_localctx, 1);
       {
-      setState(307);
+      setState(309);
       expression();
-      setState(312);
+      setState(314);
       _la = _input.LA(1);
       if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ANALYZE) | (1L << ANALYZED) | (1L << AS) | (1L << CATALOGS) | (1L << COLUMNS) | (1L << DEBUG) | (1L << EXECUTABLE) | (1L << EXPLAIN) | (1L << FORMAT) | (1L << FUNCTIONS) | (1L << GRAPHVIZ) | (1L << MAPPED) | (1L << OPTIMIZED) | (1L << PARSED) | (1L << PHYSICAL) | (1L << PLAN) | (1L << RLIKE) | (1L << QUERY) | (1L << SCHEMAS) | (1L << SHOW) | (1L << SYS) | (1L << TABLES))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TEXT - 64)) | (1L << (TYPE - 64)) | (1L << (TYPES - 64)) | (1L << (VERIFY - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (DIGIT_IDENTIFIER - 64)) | (1L << (QUOTED_IDENTIFIER - 64)) | (1L << (BACKQUOTED_IDENTIFIER - 64)))) != 0)) {
         {
-        setState(309);
+        setState(311);
         _la = _input.LA(1);
         if (_la==AS) {
           {
-          setState(308);
+          setState(310);
           match(AS);
           }
         }
 
-        setState(311);
+        setState(313);
         identifier();
         }
       }
@@ -2014,19 +2011,19 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(314);
+      setState(316);
       relationPrimary();
-      setState(318);
+      setState(320);
       _errHandler.sync(this);
       _la = _input.LA(1);
       while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FULL) | (1L << INNER) | (1L << JOIN) | (1L << LEFT) | (1L << NATURAL) | (1L << RIGHT))) != 0)) {
         {
         {
-        setState(315);
+        setState(317);
         joinRelation();
         }
         }
-        setState(320);
+        setState(322);
         _errHandler.sync(this);
         _la = _input.LA(1);
       }
@@ -2080,7 +2077,7 @@ class SqlBaseParser extends Parser {
     enterRule(_localctx, 32, RULE_joinRelation);
     int _la;
     try {
-      setState(332);
+      setState(334);
       switch (_input.LA(1)) {
       case FULL:
       case INNER:
@@ -2090,18 +2087,18 @@ class SqlBaseParser extends Parser {
         enterOuterAlt(_localctx, 1);
         {
         {
-        setState(321);
+        setState(323);
         joinType();
         }
-        setState(322);
+        setState(324);
         match(JOIN);
-        setState(323);
-        ((JoinRelationContext)_localctx).right = relationPrimary();
         setState(325);
+        ((JoinRelationContext)_localctx).right = relationPrimary();
+        setState(327);
         _la = _input.LA(1);
         if (_la==ON || _la==USING) {
           {
-          setState(324);
+          setState(326);
           joinCriteria();
           }
         }
@@ -2111,13 +2108,13 @@ class SqlBaseParser extends Parser {
       case NATURAL:
         enterOuterAlt(_localctx, 2);
         {
-        setState(327);
-        match(NATURAL);
-        setState(328);
-        joinType();
         setState(329);
-        match(JOIN);
+        match(NATURAL);
         setState(330);
+        joinType();
+        setState(331);
+        match(JOIN);
+        setState(332);
         ((JoinRelationContext)_localctx).right = relationPrimary();
         }
         break;
@@ -2166,17 +2163,17 @@ class SqlBaseParser extends Parser {
     enterRule(_localctx, 34, RULE_joinType);
     int _la;
     try {
-      setState(349);
+      setState(351);
       switch (_input.LA(1)) {
       case INNER:
       case JOIN:
         enterOuterAlt(_localctx, 1);
         {
-        setState(335);
+        setState(337);
         _la = _input.LA(1);
         if (_la==INNER) {
           {
-          setState(334);
+          setState(336);
           match(INNER);
           }
         }
@@ -2186,13 +2183,13 @@ class SqlBaseParser extends Parser {
       case LEFT:
         enterOuterAlt(_localctx, 2);
         {
-        setState(337);
-        match(LEFT);
         setState(339);
+        match(LEFT);
+        setState(341);
         _la = _input.LA(1);
         if (_la==OUTER) {
           {
-          setState(338);
+          setState(340);
           match(OUTER);
           }
         }
@@ -2202,13 +2199,13 @@ class SqlBaseParser extends Parser {
       case RIGHT:
         enterOuterAlt(_localctx, 3);
         {
-        setState(341);
-        match(RIGHT);
         setState(343);
+        match(RIGHT);
+        setState(345);
         _la = _input.LA(1);
         if (_la==OUTER) {
           {
-          setState(342);
+          setState(344);
           match(OUTER);
           }
         }
@@ -2218,13 +2215,13 @@ class SqlBaseParser extends Parser {
       case FULL:
         enterOuterAlt(_localctx, 4);
         {
-        setState(345);
-        match(FULL);
         setState(347);
+        match(FULL);
+        setState(349);
         _la = _input.LA(1);
         if (_la==OUTER) {
           {
-          setState(346);
+          setState(348);
           match(OUTER);
           }
         }
@@ -2282,43 +2279,43 @@ class SqlBaseParser extends Parser {
     enterRule(_localctx, 36, RULE_joinCriteria);
     int _la;
     try {
-      setState(365);
+      setState(367);
       switch (_input.LA(1)) {
       case ON:
         enterOuterAlt(_localctx, 1);
         {
-        setState(351);
+        setState(353);
         match(ON);
-        setState(352);
+        setState(354);
         booleanExpression(0);
         }
         break;
       case USING:
         enterOuterAlt(_localctx, 2);
         {
-        setState(353);
-        match(USING);
-        setState(354);
-        match(T__0);
         setState(355);
+        match(USING);
+        setState(356);
+        match(T__0);
+        setState(357);
         identifier();
-        setState(360);
+        setState(362);
         _errHandler.sync(this);
         _la = _input.LA(1);
         while (_la==T__2) {
           {
           {
-          setState(356);
+          setState(358);
           match(T__2);
-          setState(357);
+          setState(359);
           identifier();
           }
           }
-          setState(362);
+          setState(364);
           _errHandler.sync(this);
           _la = _input.LA(1);
         }
-        setState(363);
+        setState(365);
         match(T__1);
         }
         break;
@@ -2423,29 +2420,29 @@ class SqlBaseParser extends Parser {
     enterRule(_localctx, 38, RULE_relationPrimary);
     int _la;
     try {
-      setState(392);
+      setState(394);
       _errHandler.sync(this);
       switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
       case 1:
         _localctx = new TableNameContext(_localctx);
         enterOuterAlt(_localctx, 1);
         {
-        setState(367);
+        setState(369);
         tableIdentifier();
-        setState(372);
+        setState(374);
         _la = _input.LA(1);
         if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ANALYZE) | (1L << ANALYZED) | (1L << AS) | (1L << CATALOGS) | (1L << COLUMNS) | (1L << DEBUG) | (1L << EXECUTABLE) | (1L << EXPLAIN) | (1L << FORMAT) | (1L << FUNCTIONS) | (1L << GRAPHVIZ) | (1L << MAPPED) | (1L << OPTIMIZED) | (1L << PARSED) | (1L << PHYSICAL) | (1L << PLAN) | (1L << RLIKE) | (1L << QUERY) | (1L << SCHEMAS) | (1L << SHOW) | (1L << SYS) | (1L << TABLES))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TEXT - 64)) | (1L << (TYPE - 64)) | (1L << (TYPES - 64)) | (1L << (VERIFY - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (DIGIT_IDENTIFIER - 64)) | (1L << (QUOTED_IDENTIFIER - 64)) | (1L << (BACKQUOTED_IDENTIFIER - 64)))) != 0)) {
           {
-          setState(369);
+          setState(371);
           _la = _input.LA(1);
           if (_la==AS) {
             {
-            setState(368);
+            setState(370);
             match(AS);
             }
           }
 
-          setState(371);
+          setState(373);
           qualifiedName();
           }
         }
@@ -2456,26 +2453,26 @@ class SqlBaseParser extends Parser {
         _localctx = new AliasedQueryContext(_localctx);
         enterOuterAlt(_localctx, 2);
         {
-        setState(374);
-        match(T__0);
-        setState(375);
-        queryNoWith();
         setState(376);
+        match(T__0);
+        setState(377);
+        queryNoWith();
+        setState(378);
         match(T__1);
-        setState(381);
+        setState(383);
         _la = _input.LA(1);
         if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ANALYZE) | (1L << ANALYZED) | (1L << AS) | (1L << CATALOGS) | (1L << COLUMNS) | (1L << DEBUG) | (1L << EXECUTABLE) | (1L << EXPLAIN) | (1L << FORMAT) | (1L << FUNCTIONS) | (1L << GRAPHVIZ) | (1L << MAPPED) | (1L << OPTIMIZED) | (1L << PARSED) | (1L << PHYSICAL) | (1L << PLAN) | (1L << RLIKE) | (1L << QUERY) | (1L << SCHEMAS) | (1L << SHOW) | (1L << SYS) | (1L << TABLES))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TEXT - 64)) | (1L << (TYPE - 64)) | (1L << (TYPES - 64)) | (1L << (VERIFY - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (DIGIT_IDENTIFIER - 64)) | (1L << (QUOTED_IDENTIFIER - 64)) | (1L << (BACKQUOTED_IDENTIFIER - 64)))) != 0)) {
           {
-          setState(378);
+          setState(380);
           _la = _input.LA(1);
           if (_la==AS) {
             {
-            setState(377);
+            setState(379);
             match(AS);
             }
           }
 
-          setState(380);
+          setState(382);
           qualifiedName();
           }
         }
@@ -2486,26 +2483,26 @@ class SqlBaseParser extends Parser {
         _localctx = new AliasedRelationContext(_localctx);
         enterOuterAlt(_localctx, 3);
         {
-        setState(383);
-        match(T__0);
-        setState(384);
-        relation();
         setState(385);
+        match(T__0);
+        setState(386);
+        relation();
+        setState(387);
         match(T__1);
-        setState(390);
+        setState(392);
         _la = _input.LA(1);
         if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ANALYZE) | (1L << ANALYZED) | (1L << AS) | (1L << CATALOGS) | (1L << COLUMNS) | (1L << DEBUG) | (1L << EXECUTABLE) | (1L << EXPLAIN) | (1L << FORMAT) | (1L << FUNCTIONS) | (1L << GRAPHVIZ) | (1L << MAPPED) | (1L << OPTIMIZED) | (1L << PARSED) | (1L << PHYSICAL) | (1L << PLAN) | (1L << RLIKE) | (1L << QUERY) | (1L << SCHEMAS) | (1L << SHOW) | (1L << SYS) | (1L << TABLES))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TEXT - 64)) | (1L << (TYPE - 64)) | (1L << (TYPES - 64)) | (1L << (VERIFY - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (DIGIT_IDENTIFIER - 64)) | (1L << (QUOTED_IDENTIFIER - 64)) | (1L << (BACKQUOTED_IDENTIFIER - 64)))) != 0)) {
           {
-          setState(387);
+          setState(389);
           _la = _input.LA(1);
           if (_la==AS) {
             {
-            setState(386);
+            setState(388);
             match(AS);
             }
           }
 
-          setState(389);
+          setState(391);
           qualifiedName();
           }
         }
@@ -2554,7 +2551,7 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(394);
+      setState(396);
       booleanExpression(0);
       }
     }
@@ -2601,12 +2598,14 @@ class SqlBaseParser extends Parser {
     }
   }
   public static class StringQueryContext extends BooleanExpressionContext {
-    public Token queryString;
-    public Token options;
+    public StringContext queryString;
+    public StringContext options;
     public TerminalNode QUERY() { return getToken(SqlBaseParser.QUERY, 0); }
-    public List<TerminalNode> STRING() { return getTokens(SqlBaseParser.STRING); }
-    public TerminalNode STRING(int i) {
-      return getToken(SqlBaseParser.STRING, i);
+    public List<StringContext> string() {
+      return getRuleContexts(StringContext.class);
+    }
+    public StringContext string(int i) {
+      return getRuleContext(StringContext.class,i);
     }
     public StringQueryContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
     @Override
@@ -2663,13 +2662,15 @@ class SqlBaseParser extends Parser {
     }
   }
   public static class MultiMatchQueryContext extends BooleanExpressionContext {
-    public Token multiFields;
-    public Token queryString;
-    public Token options;
+    public StringContext multiFields;
+    public StringContext queryString;
+    public StringContext options;
     public TerminalNode MATCH() { return getToken(SqlBaseParser.MATCH, 0); }
-    public List<TerminalNode> STRING() { return getTokens(SqlBaseParser.STRING); }
-    public TerminalNode STRING(int i) {
-      return getToken(SqlBaseParser.STRING, i);
+    public List<StringContext> string() {
+      return getRuleContexts(StringContext.class);
+    }
+    public StringContext string(int i) {
+      return getRuleContext(StringContext.class,i);
     }
     public MultiMatchQueryContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
     @Override
@@ -2688,15 +2689,17 @@ class SqlBaseParser extends Parser {
   }
   public static class MatchQueryContext extends BooleanExpressionContext {
     public QualifiedNameContext singleField;
-    public Token queryString;
-    public Token options;
+    public StringContext queryString;
+    public StringContext options;
     public TerminalNode MATCH() { return getToken(SqlBaseParser.MATCH, 0); }
     public QualifiedNameContext qualifiedName() {
       return getRuleContext(QualifiedNameContext.class,0);
     }
-    public List<TerminalNode> STRING() { return getTokens(SqlBaseParser.STRING); }
-    public TerminalNode STRING(int i) {
-      return getToken(SqlBaseParser.STRING, i);
+    public List<StringContext> string() {
+      return getRuleContexts(StringContext.class);
+    }
+    public StringContext string(int i) {
+      return getRuleContext(StringContext.class,i);
     }
     public MatchQueryContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
     @Override
@@ -2757,7 +2760,7 @@ class SqlBaseParser extends Parser {
       int _alt;
       enterOuterAlt(_localctx, 1);
       {
-      setState(443);
+      setState(447);
       _errHandler.sync(this);
       switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) {
       case 1:
@@ -2766,9 +2769,9 @@ class SqlBaseParser extends Parser {
         _ctx = _localctx;
         _prevctx = _localctx;
 
-        setState(397);
+        setState(399);
         match(NOT);
-        setState(398);
+        setState(400);
         booleanExpression(8);
         }
         break;
@@ -2777,13 +2780,13 @@ class SqlBaseParser extends Parser {
         _localctx = new ExistsContext(_localctx);
         _ctx = _localctx;
         _prevctx = _localctx;
-        setState(399);
-        match(EXISTS);
-        setState(400);
-        match(T__0);
         setState(401);
-        query();
+        match(EXISTS);
         setState(402);
+        match(T__0);
+        setState(403);
+        query();
+        setState(404);
         match(T__1);
         }
         break;
@@ -2792,29 +2795,29 @@ class SqlBaseParser extends Parser {
         _localctx = new StringQueryContext(_localctx);
         _ctx = _localctx;
         _prevctx = _localctx;
-        setState(404);
-        match(QUERY);
-        setState(405);
-        match(T__0);
         setState(406);
-        ((StringQueryContext)_localctx).queryString = match(STRING);
-        setState(411);
+        match(QUERY);
+        setState(407);
+        match(T__0);
+        setState(408);
+        ((StringQueryContext)_localctx).queryString = string();
+        setState(413);
         _errHandler.sync(this);
         _la = _input.LA(1);
         while (_la==T__2) {
           {
           {
-          setState(407);
+          setState(409);
           match(T__2);
-          setState(408);
-          ((StringQueryContext)_localctx).options = match(STRING);
+          setState(410);
+          ((StringQueryContext)_localctx).options = string();
           }
           }
-          setState(413);
+          setState(415);
           _errHandler.sync(this);
           _la = _input.LA(1);
         }
-        setState(414);
+        setState(416);
         match(T__1);
         }
         break;
@@ -2823,33 +2826,33 @@ class SqlBaseParser extends Parser {
         _localctx = new MatchQueryContext(_localctx);
         _ctx = _localctx;
         _prevctx = _localctx;
-        setState(415);
-        match(MATCH);
-        setState(416);
-        match(T__0);
-        setState(417);
-        ((MatchQueryContext)_localctx).singleField = qualifiedName();
         setState(418);
-        match(T__2);
+        match(MATCH);
         setState(419);
-        ((MatchQueryContext)_localctx).queryString = match(STRING);
-        setState(424);
+        match(T__0);
+        setState(420);
+        ((MatchQueryContext)_localctx).singleField = qualifiedName();
+        setState(421);
+        match(T__2);
+        setState(422);
+        ((MatchQueryContext)_localctx).queryString = string();
+        setState(427);
         _errHandler.sync(this);
         _la = _input.LA(1);
         while (_la==T__2) {
           {
           {
-          setState(420);
+          setState(423);
           match(T__2);
-          setState(421);
-          ((MatchQueryContext)_localctx).options = match(STRING);
+          setState(424);
+          ((MatchQueryContext)_localctx).options = string();
           }
           }
-          setState(426);
+          setState(429);
           _errHandler.sync(this);
           _la = _input.LA(1);
         }
-        setState(427);
+        setState(430);
         match(T__1);
         }
         break;
@@ -2858,33 +2861,33 @@ class SqlBaseParser extends Parser {
         _localctx = new MultiMatchQueryContext(_localctx);
         _ctx = _localctx;
         _prevctx = _localctx;
-        setState(429);
-        match(MATCH);
-        setState(430);
-        match(T__0);
-        setState(431);
-        ((MultiMatchQueryContext)_localctx).multiFields = match(STRING);
         setState(432);
-        match(T__2);
+        match(MATCH);
         setState(433);
-        ((MultiMatchQueryContext)_localctx).queryString = match(STRING);
-        setState(438);
+        match(T__0);
+        setState(434);
+        ((MultiMatchQueryContext)_localctx).multiFields = string();
+        setState(435);
+        match(T__2);
+        setState(436);
+        ((MultiMatchQueryContext)_localctx).queryString = string();
+        setState(441);
         _errHandler.sync(this);
         _la = _input.LA(1);
         while (_la==T__2) {
           {
           {
-          setState(434);
+          setState(437);
           match(T__2);
-          setState(435);
-          ((MultiMatchQueryContext)_localctx).options = match(STRING);
+          setState(438);
+          ((MultiMatchQueryContext)_localctx).options = string();
           }
           }
-          setState(440);
+          setState(443);
           _errHandler.sync(this);
           _la = _input.LA(1);
         }
-        setState(441);
+        setState(444);
         match(T__1);
         }
         break;
@@ -2893,13 +2896,13 @@ class SqlBaseParser extends Parser {
         _localctx = new BooleanDefaultContext(_localctx);
         _ctx = _localctx;
         _prevctx = _localctx;
-        setState(442);
+        setState(446);
         predicated();
         }
         break;
       }
       _ctx.stop = _input.LT(-1);
-      setState(453);
+      setState(457);
       _errHandler.sync(this);
       _alt = getInterpreter().adaptivePredict(_input,65,_ctx);
       while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
@@ -2907,7 +2910,7 @@ class SqlBaseParser extends Parser {
           if ( _parseListeners!=null ) triggerExitRuleEvent();
           _prevctx = _localctx;
           {
-          setState(451);
+          setState(455);
           _errHandler.sync(this);
           switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
           case 1:
@@ -2915,11 +2918,11 @@ class SqlBaseParser extends Parser {
             _localctx = new LogicalBinaryContext(new BooleanExpressionContext(_parentctx, _parentState));
             ((LogicalBinaryContext)_localctx).left = _prevctx;
             pushNewRecursionContext(_localctx, _startState, RULE_booleanExpression);
-            setState(445);
+            setState(449);
             if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
-            setState(446);
+            setState(450);
             ((LogicalBinaryContext)_localctx).operator = match(AND);
-            setState(447);
+            setState(451);
             ((LogicalBinaryContext)_localctx).right = booleanExpression(3);
             }
             break;
@@ -2928,18 +2931,18 @@ class SqlBaseParser extends Parser {
             _localctx = new LogicalBinaryContext(new BooleanExpressionContext(_parentctx, _parentState));
             ((LogicalBinaryContext)_localctx).left = _prevctx;
             pushNewRecursionContext(_localctx, _startState, RULE_booleanExpression);
-            setState(448);
+            setState(452);
             if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
-            setState(449);
+            setState(453);
             ((LogicalBinaryContext)_localctx).operator = match(OR);
-            setState(450);
+            setState(454);
             ((LogicalBinaryContext)_localctx).right = booleanExpression(2);
             }
             break;
           }
           } 
         }
-        setState(455);
+        setState(459);
         _errHandler.sync(this);
         _alt = getInterpreter().adaptivePredict(_input,65,_ctx);
       }
@@ -2988,14 +2991,14 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(456);
+      setState(460);
       valueExpression(0);
-      setState(458);
+      setState(462);
       _errHandler.sync(this);
       switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
       case 1:
         {
-        setState(457);
+        setState(461);
         predicate();
         }
         break;
@@ -3017,7 +3020,7 @@ class SqlBaseParser extends Parser {
     public Token kind;
     public ValueExpressionContext lower;
     public ValueExpressionContext upper;
-    public Token regex;
+    public StringContext regex;
     public TerminalNode AND() { return getToken(SqlBaseParser.AND, 0); }
     public TerminalNode BETWEEN() { return getToken(SqlBaseParser.BETWEEN, 0); }
     public List<ValueExpressionContext> valueExpression() {
@@ -3042,7 +3045,9 @@ class SqlBaseParser extends Parser {
     }
     public TerminalNode LIKE() { return getToken(SqlBaseParser.LIKE, 0); }
     public TerminalNode RLIKE() { return getToken(SqlBaseParser.RLIKE, 0); }
-    public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
+    public StringContext string() {
+      return getRuleContext(StringContext.class,0);
+    }
     public TerminalNode IS() { return getToken(SqlBaseParser.IS, 0); }
     public TerminalNode NULL() { return getToken(SqlBaseParser.NULL, 0); }
     public PredicateContext(ParserRuleContext parent, int invokingState) {
@@ -3069,142 +3074,142 @@ class SqlBaseParser extends Parser {
     enterRule(_localctx, 46, RULE_predicate);
     int _la;
     try {
-      setState(506);
+      setState(510);
       _errHandler.sync(this);
       switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
       case 1:
         enterOuterAlt(_localctx, 1);
         {
-        setState(461);
+        setState(465);
         _la = _input.LA(1);
         if (_la==NOT) {
           {
-          setState(460);
+          setState(464);
           match(NOT);
           }
         }
 
-        setState(463);
+        setState(467);
         ((PredicateContext)_localctx).kind = match(BETWEEN);
-        setState(464);
+        setState(468);
         ((PredicateContext)_localctx).lower = valueExpression(0);
-        setState(465);
+        setState(469);
         match(AND);
-        setState(466);
+        setState(470);
         ((PredicateContext)_localctx).upper = valueExpression(0);
         }
         break;
       case 2:
         enterOuterAlt(_localctx, 2);
         {
-        setState(469);
+        setState(473);
         _la = _input.LA(1);
         if (_la==NOT) {
           {
-          setState(468);
+          setState(472);
           match(NOT);
           }
         }
 
-        setState(471);
+        setState(475);
         ((PredicateContext)_localctx).kind = match(IN);
-        setState(472);
+        setState(476);
         match(T__0);
-        setState(473);
+        setState(477);
         expression();
-        setState(478);
+        setState(482);
         _errHandler.sync(this);
         _la = _input.LA(1);
         while (_la==T__2) {
           {
           {
-          setState(474);
+          setState(478);
           match(T__2);
-          setState(475);
+          setState(479);
           expression();
           }
           }
-          setState(480);
+          setState(484);
           _errHandler.sync(this);
           _la = _input.LA(1);
         }
-        setState(481);
+        setState(485);
         match(T__1);
         }
         break;
       case 3:
         enterOuterAlt(_localctx, 3);
         {
-        setState(484);
+        setState(488);
         _la = _input.LA(1);
         if (_la==NOT) {
           {
-          setState(483);
+          setState(487);
           match(NOT);
           }
         }
 
-        setState(486);
+        setState(490);
         ((PredicateContext)_localctx).kind = match(IN);
-        setState(487);
+        setState(491);
         match(T__0);
-        setState(488);
+        setState(492);
         query();
-        setState(489);
+        setState(493);
         match(T__1);
         }
         break;
       case 4:
         enterOuterAlt(_localctx, 4);
         {
-        setState(492);
+        setState(496);
         _la = _input.LA(1);
         if (_la==NOT) {
           {
-          setState(491);
+          setState(495);
           match(NOT);
           }
         }
 
-        setState(494);
+        setState(498);
         ((PredicateContext)_localctx).kind = match(LIKE);
-        setState(495);
+        setState(499);
         pattern();
         }
         break;
       case 5:
         enterOuterAlt(_localctx, 5);
         {
-        setState(497);
+        setState(501);
         _la = _input.LA(1);
         if (_la==NOT) {
           {
-          setState(496);
+          setState(500);
           match(NOT);
           }
         }
 
-        setState(499);
+        setState(503);
         ((PredicateContext)_localctx).kind = match(RLIKE);
-        setState(500);
-        ((PredicateContext)_localctx).regex = match(STRING);
+        setState(504);
+        ((PredicateContext)_localctx).regex = string();
         }
         break;
       case 6:
         enterOuterAlt(_localctx, 6);
         {
-        setState(501);
+        setState(505);
         match(IS);
-        setState(503);
+        setState(507);
         _la = _input.LA(1);
         if (_la==NOT) {
           {
-          setState(502);
+          setState(506);
           match(NOT);
           }
         }
 
-        setState(505);
+        setState(509);
         ((PredicateContext)_localctx).kind = match(NULL);
         }
         break;
@@ -3222,14 +3227,15 @@ class SqlBaseParser extends Parser {
   }
 
   public static class PatternContext extends ParserRuleContext {
-    public Token value;
-    public Token escape;
-    public List<TerminalNode> STRING() { return getTokens(SqlBaseParser.STRING); }
-    public TerminalNode STRING(int i) {
-      return getToken(SqlBaseParser.STRING, i);
+    public StringContext value;
+    public StringContext escape;
+    public List<StringContext> string() {
+      return getRuleContexts(StringContext.class);
+    }
+    public StringContext string(int i) {
+      return getRuleContext(StringContext.class,i);
     }
     public TerminalNode ESCAPE() { return getToken(SqlBaseParser.ESCAPE, 0); }
-    public TerminalNode PARAM() { return getToken(SqlBaseParser.PARAM, 0); }
     public PatternContext(ParserRuleContext parent, int invokingState) {
       super(parent, invokingState);
     }
@@ -3253,36 +3259,22 @@ class SqlBaseParser extends Parser {
     PatternContext _localctx = new PatternContext(_ctx, getState());
     enterRule(_localctx, 48, RULE_pattern);
     try {
-      setState(514);
-      switch (_input.LA(1)) {
-      case STRING:
-        enterOuterAlt(_localctx, 1);
-        {
-        setState(508);
-        ((PatternContext)_localctx).value = match(STRING);
-        setState(511);
-        _errHandler.sync(this);
-        switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
-        case 1:
-          {
-          setState(509);
-          match(ESCAPE);
-          setState(510);
-          ((PatternContext)_localctx).escape = match(STRING);
-          }
-          break;
-        }
-        }
-        break;
-      case PARAM:
-        enterOuterAlt(_localctx, 2);
+      enterOuterAlt(_localctx, 1);
+      {
+      setState(512);
+      ((PatternContext)_localctx).value = string();
+      setState(515);
+      _errHandler.sync(this);
+      switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
+      case 1:
         {
         setState(513);
-        match(PARAM);
+        match(ESCAPE);
+        setState(514);
+        ((PatternContext)_localctx).escape = string();
         }
         break;
-      default:
-        throw new NoViableAltException(this);
+      }
       }
     }
     catch (RecognitionException re) {
@@ -3422,7 +3414,7 @@ class SqlBaseParser extends Parser {
       int _alt;
       enterOuterAlt(_localctx, 1);
       {
-      setState(520);
+      setState(521);
       switch (_input.LA(1)) {
       case T__0:
       case ANALYZE:
@@ -3469,7 +3461,7 @@ class SqlBaseParser extends Parser {
         _ctx = _localctx;
         _prevctx = _localctx;
 
-        setState(517);
+        setState(518);
         primaryExpression();
         }
         break;
@@ -3479,7 +3471,7 @@ class SqlBaseParser extends Parser {
         _localctx = new ArithmeticUnaryContext(_localctx);
         _ctx = _localctx;
         _prevctx = _localctx;
-        setState(518);
+        setState(519);
         ((ArithmeticUnaryContext)_localctx).operator = _input.LT(1);
         _la = _input.LA(1);
         if ( !(_la==PLUS || _la==MINUS) ) {
@@ -3487,7 +3479,7 @@ class SqlBaseParser extends Parser {
         } else {
           consume();
         }
-        setState(519);
+        setState(520);
         valueExpression(4);
         }
         break;
@@ -3495,25 +3487,25 @@ class SqlBaseParser extends Parser {
         throw new NoViableAltException(this);
       }
       _ctx.stop = _input.LT(-1);
-      setState(534);
+      setState(535);
       _errHandler.sync(this);
-      _alt = getInterpreter().adaptivePredict(_input,79,_ctx);
+      _alt = getInterpreter().adaptivePredict(_input,78,_ctx);
       while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
         if ( _alt==1 ) {
           if ( _parseListeners!=null ) triggerExitRuleEvent();
           _prevctx = _localctx;
           {
-          setState(532);
+          setState(533);
           _errHandler.sync(this);
-          switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
+          switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
           case 1:
             {
             _localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState));
             ((ArithmeticBinaryContext)_localctx).left = _prevctx;
             pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
-            setState(522);
-            if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
             setState(523);
+            if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
+            setState(524);
             ((ArithmeticBinaryContext)_localctx).operator = _input.LT(1);
             _la = _input.LA(1);
             if ( !(((((_la - 80)) & ~0x3f) == 0 && ((1L << (_la - 80)) & ((1L << (ASTERISK - 80)) | (1L << (SLASH - 80)) | (1L << (PERCENT - 80)))) != 0)) ) {
@@ -3521,7 +3513,7 @@ class SqlBaseParser extends Parser {
             } else {
               consume();
             }
-            setState(524);
+            setState(525);
             ((ArithmeticBinaryContext)_localctx).right = valueExpression(4);
             }
             break;
@@ -3530,9 +3522,9 @@ class SqlBaseParser extends Parser {
             _localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState));
             ((ArithmeticBinaryContext)_localctx).left = _prevctx;
             pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
-            setState(525);
-            if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
             setState(526);
+            if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
+            setState(527);
             ((ArithmeticBinaryContext)_localctx).operator = _input.LT(1);
             _la = _input.LA(1);
             if ( !(_la==PLUS || _la==MINUS) ) {
@@ -3540,7 +3532,7 @@ class SqlBaseParser extends Parser {
             } else {
               consume();
             }
-            setState(527);
+            setState(528);
             ((ArithmeticBinaryContext)_localctx).right = valueExpression(3);
             }
             break;
@@ -3549,20 +3541,20 @@ class SqlBaseParser extends Parser {
             _localctx = new ComparisonContext(new ValueExpressionContext(_parentctx, _parentState));
             ((ComparisonContext)_localctx).left = _prevctx;
             pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
-            setState(528);
-            if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
             setState(529);
-            comparisonOperator();
+            if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
             setState(530);
+            comparisonOperator();
+            setState(531);
             ((ComparisonContext)_localctx).right = valueExpression(2);
             }
             break;
           }
           } 
         }
-        setState(536);
+        setState(537);
         _errHandler.sync(this);
-        _alt = getInterpreter().adaptivePredict(_input,79,_ctx);
+        _alt = getInterpreter().adaptivePredict(_input,78,_ctx);
       }
       }
     }
@@ -3787,24 +3779,24 @@ class SqlBaseParser extends Parser {
     enterRule(_localctx, 52, RULE_primaryExpression);
     int _la;
     try {
-      setState(586);
+      setState(587);
       _errHandler.sync(this);
-      switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
+      switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) {
       case 1:
         _localctx = new CastContext(_localctx);
         enterOuterAlt(_localctx, 1);
         {
-        setState(537);
-        match(CAST);
         setState(538);
-        match(T__0);
+        match(CAST);
         setState(539);
-        expression();
+        match(T__0);
         setState(540);
-        match(AS);
+        expression();
         setState(541);
-        dataType();
+        match(AS);
         setState(542);
+        dataType();
+        setState(543);
         match(T__1);
         }
         break;
@@ -3812,17 +3804,17 @@ class SqlBaseParser extends Parser {
         _localctx = new ExtractContext(_localctx);
         enterOuterAlt(_localctx, 2);
         {
-        setState(544);
-        match(EXTRACT);
         setState(545);
-        match(T__0);
+        match(EXTRACT);
         setState(546);
-        ((ExtractContext)_localctx).field = identifier();
+        match(T__0);
         setState(547);
-        match(FROM);
+        ((ExtractContext)_localctx).field = identifier();
         setState(548);
-        valueExpression(0);
+        match(FROM);
         setState(549);
+        valueExpression(0);
+        setState(550);
         match(T__1);
         }
         break;
@@ -3830,7 +3822,7 @@ class SqlBaseParser extends Parser {
         _localctx = new ConstantDefaultContext(_localctx);
         enterOuterAlt(_localctx, 3);
         {
-        setState(551);
+        setState(552);
         constant();
         }
         break;
@@ -3838,7 +3830,7 @@ class SqlBaseParser extends Parser {
         _localctx = new StarContext(_localctx);
         enterOuterAlt(_localctx, 4);
         {
-        setState(552);
+        setState(553);
         match(ASTERISK);
         }
         break;
@@ -3846,18 +3838,18 @@ class SqlBaseParser extends Parser {
         _localctx = new StarContext(_localctx);
         enterOuterAlt(_localctx, 5);
         {
-        setState(556);
+        setState(557);
         _la = _input.LA(1);
         if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ANALYZE) | (1L << ANALYZED) | (1L << CATALOGS) | (1L << COLUMNS) | (1L << DEBUG) | (1L << EXECUTABLE) | (1L << EXPLAIN) | (1L << FORMAT) | (1L << FUNCTIONS) | (1L << GRAPHVIZ) | (1L << MAPPED) | (1L << OPTIMIZED) | (1L << PARSED) | (1L << PHYSICAL) | (1L << PLAN) | (1L << RLIKE) | (1L << QUERY) | (1L << SCHEMAS) | (1L << SHOW) | (1L << SYS) | (1L << TABLES))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TEXT - 64)) | (1L << (TYPE - 64)) | (1L << (TYPES - 64)) | (1L << (VERIFY - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (DIGIT_IDENTIFIER - 64)) | (1L << (QUOTED_IDENTIFIER - 64)) | (1L << (BACKQUOTED_IDENTIFIER - 64)))) != 0)) {
           {
-          setState(553);
-          qualifiedName();
           setState(554);
+          qualifiedName();
+          setState(555);
           match(DOT);
           }
         }
 
-        setState(558);
+        setState(559);
         match(ASTERISK);
         }
         break;
@@ -3865,45 +3857,45 @@ class SqlBaseParser extends Parser {
         _localctx = new FunctionCallContext(_localctx);
         enterOuterAlt(_localctx, 6);
         {
-        setState(559);
-        identifier();
         setState(560);
+        identifier();
+        setState(561);
         match(T__0);
-        setState(572);
+        setState(573);
         _la = _input.LA(1);
         if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << ALL) | (1L << ANALYZE) | (1L << ANALYZED) | (1L << CAST) | (1L << CATALOGS) | (1L << COLUMNS) | (1L << DEBUG) | (1L << DISTINCT) | (1L << EXECUTABLE) | (1L << EXISTS) | (1L << EXPLAIN) | (1L << EXTRACT) | (1L << FALSE) | (1L << FORMAT) | (1L << FUNCTIONS) | (1L << GRAPHVIZ) | (1L << MAPPED) | (1L << MATCH) | (1L << NOT) | (1L << NULL) | (1L << OPTIMIZED) | (1L << PARSED) | (1L << PHYSICAL) | (1L << PLAN) | (1L << RLIKE) | (1L << QUERY) | (1L << SCHEMAS) | (1L << SHOW) | (1L << SYS) | (1L << TABLES))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TEXT - 64)) | (1L << (TRUE - 64)) | (1L << (TYPE - 64)) | (1L << (TYPES - 64)) | (1L << (VERIFY - 64)) | (1L << (PLUS - 64)) | (1L << (MINUS - 64)) | (1L << (ASTERISK - 64)) | (1L << (PARAM - 64)) | (1L << (STRING - 64)) | (1L << (INTEGER_VALUE - 64)) | (1L << (DECIMAL_VALUE - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (DIGIT_IDENTIFIER - 64)) | (1L << (QUOTED_IDENTIFIER - 64)) | (1L << (BACKQUOTED_IDENTIFIER - 64)))) != 0)) {
           {
-          setState(562);
+          setState(563);
           _la = _input.LA(1);
           if (_la==ALL || _la==DISTINCT) {
             {
-            setState(561);
+            setState(562);
             setQuantifier();
             }
           }
 
-          setState(564);
+          setState(565);
           expression();
-          setState(569);
+          setState(570);
           _errHandler.sync(this);
           _la = _input.LA(1);
           while (_la==T__2) {
             {
             {
-            setState(565);
-            match(T__2);
             setState(566);
+            match(T__2);
+            setState(567);
             expression();
             }
             }
-            setState(571);
+            setState(572);
             _errHandler.sync(this);
             _la = _input.LA(1);
           }
           }
         }
 
-        setState(574);
+        setState(575);
         match(T__1);
         }
         break;
@@ -3911,11 +3903,11 @@ class SqlBaseParser extends Parser {
         _localctx = new SubqueryExpressionContext(_localctx);
         enterOuterAlt(_localctx, 7);
         {
-        setState(576);
-        match(T__0);
         setState(577);
-        query();
+        match(T__0);
         setState(578);
+        query();
+        setState(579);
         match(T__1);
         }
         break;
@@ -3923,7 +3915,7 @@ class SqlBaseParser extends Parser {
         _localctx = new ColumnReferenceContext(_localctx);
         enterOuterAlt(_localctx, 8);
         {
-        setState(580);
+        setState(581);
         identifier();
         }
         break;
@@ -3931,7 +3923,7 @@ class SqlBaseParser extends Parser {
         _localctx = new DereferenceContext(_localctx);
         enterOuterAlt(_localctx, 9);
         {
-        setState(581);
+        setState(582);
         qualifiedName();
         }
         break;
@@ -3939,11 +3931,11 @@ class SqlBaseParser extends Parser {
         _localctx = new ParenthesizedExpressionContext(_localctx);
         enterOuterAlt(_localctx, 10);
         {
-        setState(582);
-        match(T__0);
         setState(583);
-        expression();
+        match(T__0);
         setState(584);
+        expression();
+        setState(585);
         match(T__1);
         }
         break;
@@ -4008,20 +4000,20 @@ class SqlBaseParser extends Parser {
       else return visitor.visitChildren(this);
     }
   }
-  public static class ParamContext extends ConstantContext {
+  public static class ParamLiteralContext extends ConstantContext {
     public TerminalNode PARAM() { return getToken(SqlBaseParser.PARAM, 0); }
-    public ParamContext(ConstantContext ctx) { copyFrom(ctx); }
+    public ParamLiteralContext(ConstantContext ctx) { copyFrom(ctx); }
     @Override
     public void enterRule(ParseTreeListener listener) {
-      if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterParam(this);
+      if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterParamLiteral(this);
     }
     @Override
     public void exitRule(ParseTreeListener listener) {
-      if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitParam(this);
+      if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitParamLiteral(this);
     }
     @Override
     public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
-      if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor<? extends T>)visitor).visitParam(this);
+      if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor<? extends T>)visitor).visitParamLiteral(this);
       else return visitor.visitChildren(this);
     }
   }
@@ -4069,13 +4061,13 @@ class SqlBaseParser extends Parser {
     enterRule(_localctx, 54, RULE_constant);
     try {
       int _alt;
-      setState(597);
+      setState(598);
       switch (_input.LA(1)) {
       case NULL:
         _localctx = new NullLiteralContext(_localctx);
         enterOuterAlt(_localctx, 1);
         {
-        setState(588);
+        setState(589);
         match(NULL);
         }
         break;
@@ -4084,7 +4076,7 @@ class SqlBaseParser extends Parser {
         _localctx = new NumericLiteralContext(_localctx);
         enterOuterAlt(_localctx, 2);
         {
-        setState(589);
+        setState(590);
         number();
         }
         break;
@@ -4093,7 +4085,7 @@ class SqlBaseParser extends Parser {
         _localctx = new BooleanLiteralContext(_localctx);
         enterOuterAlt(_localctx, 3);
         {
-        setState(590);
+        setState(591);
         booleanValue();
         }
         break;
@@ -4101,7 +4093,7 @@ class SqlBaseParser extends Parser {
         _localctx = new StringLiteralContext(_localctx);
         enterOuterAlt(_localctx, 4);
         {
-        setState(592); 
+        setState(593); 
         _errHandler.sync(this);
         _alt = 1;
         do {
@@ -4109,7 +4101,7 @@ class SqlBaseParser extends Parser {
           case 1:
             {
             {
-            setState(591);
+            setState(592);
             match(STRING);
             }
             }
@@ -4117,17 +4109,17 @@ class SqlBaseParser extends Parser {
           default:
             throw new NoViableAltException(this);
           }
-          setState(594); 
+          setState(595); 
           _errHandler.sync(this);
-          _alt = getInterpreter().adaptivePredict(_input,85,_ctx);
+          _alt = getInterpreter().adaptivePredict(_input,84,_ctx);
         } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
         }
         break;
       case PARAM:
-        _localctx = new ParamContext(_localctx);
+        _localctx = new ParamLiteralContext(_localctx);
         enterOuterAlt(_localctx, 5);
         {
-        setState(596);
+        setState(597);
         match(PARAM);
         }
         break;
@@ -4179,7 +4171,7 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(599);
+      setState(600);
       _la = _input.LA(1);
       if ( !(((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (EQ - 72)) | (1L << (NEQ - 72)) | (1L << (LT - 72)) | (1L << (LTE - 72)) | (1L << (GT - 72)) | (1L << (GTE - 72)))) != 0)) ) {
       _errHandler.recoverInline(this);
@@ -4228,7 +4220,7 @@ class SqlBaseParser extends Parser {
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(601);
+      setState(602);
       _la = _input.LA(1);
       if ( !(_la==FALSE || _la==TRUE) ) {
       _errHandler.recoverInline(this);
@@ -4286,7 +4278,7 @@ class SqlBaseParser extends Parser {
       _localctx = new PrimitiveDataTypeContext(_localctx);
       enterOuterAlt(_localctx, 1);
       {
-      setState(603);
+      setState(604);
       identifier();
       }
     }
@@ -4338,25 +4330,25 @@ class SqlBaseParser extends Parser {
       int _alt;
       enterOuterAlt(_localctx, 1);
       {
-      setState(610);
+      setState(611);
       _errHandler.sync(this);
-      _alt = getInterpreter().adaptivePredict(_input,87,_ctx);
+      _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
       while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
         if ( _alt==1 ) {
           {
           {
-          setState(605);
-          identifier();
           setState(606);
+          identifier();
+          setState(607);
           match(DOT);
           }
           } 
         }
-        setState(612);
+        setState(613);
         _errHandler.sync(this);
-        _alt = getInterpreter().adaptivePredict(_input,87,_ctx);
+        _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
       }
-      setState(613);
+      setState(614);
       identifier();
       }
     }
@@ -4401,13 +4393,13 @@ class SqlBaseParser extends Parser {
     IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
     enterRule(_localctx, 64, RULE_identifier);
     try {
-      setState(617);
+      setState(618);
       switch (_input.LA(1)) {
       case QUOTED_IDENTIFIER:
       case BACKQUOTED_IDENTIFIER:
         enterOuterAlt(_localctx, 1);
         {
-        setState(615);
+        setState(616);
         quoteIdentifier();
         }
         break;
@@ -4440,7 +4432,7 @@ class SqlBaseParser extends Parser {
       case DIGIT_IDENTIFIER:
         enterOuterAlt(_localctx, 2);
         {
-        setState(616);
+        setState(617);
         unquoteIdentifier();
         }
         break;
@@ -4493,43 +4485,43 @@ class SqlBaseParser extends Parser {
     enterRule(_localctx, 66, RULE_tableIdentifier);
     int _la;
     try {
-      setState(631);
+      setState(632);
       _errHandler.sync(this);
-      switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) {
+      switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
       case 1:
         enterOuterAlt(_localctx, 1);
         {
-        setState(622);
+        setState(623);
         _la = _input.LA(1);
         if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ANALYZE) | (1L << ANALYZED) | (1L << CATALOGS) | (1L << COLUMNS) | (1L << DEBUG) | (1L << EXECUTABLE) | (1L << EXPLAIN) | (1L << FORMAT) | (1L << FUNCTIONS) | (1L << GRAPHVIZ) | (1L << MAPPED) | (1L << OPTIMIZED) | (1L << PARSED) | (1L << PHYSICAL) | (1L << PLAN) | (1L << RLIKE) | (1L << QUERY) | (1L << SCHEMAS) | (1L << SHOW) | (1L << SYS) | (1L << TABLES))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TEXT - 64)) | (1L << (TYPE - 64)) | (1L << (TYPES - 64)) | (1L << (VERIFY - 64)) | (1L << (IDENTIFIER - 64)) | (1L << (DIGIT_IDENTIFIER - 64)) | (1L << (QUOTED_IDENTIFIER - 64)) | (1L << (BACKQUOTED_IDENTIFIER - 64)))) != 0)) {
           {
-          setState(619);
-          ((TableIdentifierContext)_localctx).catalog = identifier();
           setState(620);
+          ((TableIdentifierContext)_localctx).catalog = identifier();
+          setState(621);
           match(T__3);
           }
         }
 
-        setState(624);
+        setState(625);
         match(TABLE_IDENTIFIER);
         }
         break;
       case 2:
         enterOuterAlt(_localctx, 2);
         {
-        setState(628);
+        setState(629);
         _errHandler.sync(this);
-        switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
+        switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
         case 1:
           {
-          setState(625);
-          ((TableIdentifierContext)_localctx).catalog = identifier();
           setState(626);
+          ((TableIdentifierContext)_localctx).catalog = identifier();
+          setState(627);
           match(T__3);
           }
           break;
         }
-        setState(630);
+        setState(631);
         ((TableIdentifierContext)_localctx).name = identifier();
         }
         break;
@@ -4596,13 +4588,13 @@ class SqlBaseParser extends Parser {
     QuoteIdentifierContext _localctx = new QuoteIdentifierContext(_ctx, getState());
     enterRule(_localctx, 68, RULE_quoteIdentifier);
     try {
-      setState(635);
+      setState(636);
       switch (_input.LA(1)) {
       case QUOTED_IDENTIFIER:
         _localctx = new QuotedIdentifierContext(_localctx);
         enterOuterAlt(_localctx, 1);
         {
-        setState(633);
+        setState(634);
         match(QUOTED_IDENTIFIER);
         }
         break;
@@ -4610,7 +4602,7 @@ class SqlBaseParser extends Parser {
         _localctx = new BackQuotedIdentifierContext(_localctx);
         enterOuterAlt(_localctx, 2);
         {
-        setState(634);
+        setState(635);
         match(BACKQUOTED_IDENTIFIER);
         }
         break;
@@ -4682,13 +4674,13 @@ class SqlBaseParser extends Parser {
     UnquoteIdentifierContext _localctx = new UnquoteIdentifierContext(_ctx, getState());
     enterRule(_localctx, 70, RULE_unquoteIdentifier);
     try {
-      setState(640);
+      setState(641);
       switch (_input.LA(1)) {
       case IDENTIFIER:
         _localctx = new UnquotedIdentifierContext(_localctx);
         enterOuterAlt(_localctx, 1);
         {
-        setState(637);
+        setState(638);
         match(IDENTIFIER);
         }
         break;
@@ -4720,7 +4712,7 @@ class SqlBaseParser extends Parser {
         _localctx = new UnquotedIdentifierContext(_localctx);
         enterOuterAlt(_localctx, 2);
         {
-        setState(638);
+        setState(639);
         nonReserved();
         }
         break;
@@ -4728,7 +4720,7 @@ class SqlBaseParser extends Parser {
         _localctx = new DigitIdentifierContext(_localctx);
         enterOuterAlt(_localctx, 3);
         {
-        setState(639);
+        setState(640);
         match(DIGIT_IDENTIFIER);
         }
         break;
@@ -4797,13 +4789,13 @@ class SqlBaseParser extends Parser {
     NumberContext _localctx = new NumberContext(_ctx, getState());
     enterRule(_localctx, 72, RULE_number);
     try {
-      setState(644);
+      setState(645);
       switch (_input.LA(1)) {
       case DECIMAL_VALUE:
         _localctx = new DecimalLiteralContext(_localctx);
         enterOuterAlt(_localctx, 1);
         {
-        setState(642);
+        setState(643);
         match(DECIMAL_VALUE);
         }
         break;
@@ -4811,7 +4803,7 @@ class SqlBaseParser extends Parser {
         _localctx = new IntegerLiteralContext(_localctx);
         enterOuterAlt(_localctx, 2);
         {
-        setState(643);
+        setState(644);
         match(INTEGER_VALUE);
         }
         break;
@@ -4830,6 +4822,55 @@ class SqlBaseParser extends Parser {
     return _localctx;
   }
 
+  public static class StringContext extends ParserRuleContext {
+    public TerminalNode PARAM() { return getToken(SqlBaseParser.PARAM, 0); }
+    public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
+    public StringContext(ParserRuleContext parent, int invokingState) {
+      super(parent, invokingState);
+    }
+    @Override public int getRuleIndex() { return RULE_string; }
+    @Override
+    public void enterRule(ParseTreeListener listener) {
+      if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterString(this);
+    }
+    @Override
+    public void exitRule(ParseTreeListener listener) {
+      if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitString(this);
+    }
+    @Override
+    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+      if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor<? extends T>)visitor).visitString(this);
+      else return visitor.visitChildren(this);
+    }
+  }
+
+  public final StringContext string() throws RecognitionException {
+    StringContext _localctx = new StringContext(_ctx, getState());
+    enterRule(_localctx, 74, RULE_string);
+    int _la;
+    try {
+      enterOuterAlt(_localctx, 1);
+      {
+      setState(647);
+      _la = _input.LA(1);
+      if ( !(_la==PARAM || _la==STRING) ) {
+      _errHandler.recoverInline(this);
+      } else {
+        consume();
+      }
+      }
+    }
+    catch (RecognitionException re) {
+      _localctx.exception = re;
+      _errHandler.reportError(this, re);
+      _errHandler.recover(this, re);
+    }
+    finally {
+      exitRule();
+    }
+    return _localctx;
+  }
+
   public static class NonReservedContext extends ParserRuleContext {
     public TerminalNode ANALYZE() { return getToken(SqlBaseParser.ANALYZE, 0); }
     public TerminalNode ANALYZED() { return getToken(SqlBaseParser.ANALYZED, 0); }
@@ -4877,12 +4918,12 @@ class SqlBaseParser extends Parser {
 
   public final NonReservedContext nonReserved() throws RecognitionException {
     NonReservedContext _localctx = new NonReservedContext(_ctx, getState());
-    enterRule(_localctx, 74, RULE_nonReserved);
+    enterRule(_localctx, 76, RULE_nonReserved);
     int _la;
     try {
       enterOuterAlt(_localctx, 1);
       {
-      setState(646);
+      setState(649);
       _la = _input.LA(1);
       if ( !(((((_la - 6)) & ~0x3f) == 0 && ((1L << (_la - 6)) & ((1L << (ANALYZE - 6)) | (1L << (ANALYZED - 6)) | (1L << (CATALOGS - 6)) | (1L << (COLUMNS - 6)) | (1L << (DEBUG - 6)) | (1L << (EXECUTABLE - 6)) | (1L << (EXPLAIN - 6)) | (1L << (FORMAT - 6)) | (1L << (FUNCTIONS - 6)) | (1L << (GRAPHVIZ - 6)) | (1L << (MAPPED - 6)) | (1L << (OPTIMIZED - 6)) | (1L << (PARSED - 6)) | (1L << (PHYSICAL - 6)) | (1L << (PLAN - 6)) | (1L << (RLIKE - 6)) | (1L << (QUERY - 6)) | (1L << (SCHEMAS - 6)) | (1L << (SHOW - 6)) | (1L << (SYS - 6)) | (1L << (TABLES - 6)) | (1L << (TEXT - 6)) | (1L << (TYPE - 6)) | (1L << (TYPES - 6)) | (1L << (VERIFY - 6)))) != 0)) ) {
       _errHandler.recoverInline(this);
@@ -4933,266 +4974,266 @@ class SqlBaseParser extends Parser {
   }
 
   public static final String _serializedATN =
-    "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3d\u028b\4\2\t\2\4"+
+    "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3d\u028e\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\4\36\t\36\4\37\t\37\4 \t \4!"+
-    "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\3\2\3\2\3\2\3\3\3\3\3\3\3"+
-    "\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\7\4^\n\4\f\4\16\4a\13\4\3\4\5\4d\n"+
-    "\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\7\4m\n\4\f\4\16\4p\13\4\3\4\5\4s\n\4\3"+
-    "\4\3\4\3\4\3\4\5\4y\n\4\3\4\5\4|\n\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3"+
-    "\4\5\4\u0087\n\4\3\4\5\4\u008a\n\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4"+
-    "\u0094\n\4\3\4\5\4\u0097\n\4\3\4\5\4\u009a\n\4\3\4\5\4\u009d\n\4\3\4\3"+
-    "\4\3\4\3\4\7\4\u00a3\n\4\f\4\16\4\u00a6\13\4\5\4\u00a8\n\4\3\4\3\4\3\4"+
-    "\3\4\5\4\u00ae\n\4\3\4\3\4\5\4\u00b2\n\4\3\4\5\4\u00b5\n\4\3\4\5\4\u00b8"+
-    "\n\4\3\4\5\4\u00bb\n\4\3\4\3\4\3\4\3\4\3\4\5\4\u00c2\n\4\3\5\3\5\3\5\3"+
-    "\5\7\5\u00c8\n\5\f\5\16\5\u00cb\13\5\5\5\u00cd\n\5\3\5\3\5\3\6\3\6\3\6"+
-    "\3\6\3\6\3\6\7\6\u00d7\n\6\f\6\16\6\u00da\13\6\5\6\u00dc\n\6\3\6\3\6\5"+
-    "\6\u00e0\n\6\3\7\3\7\3\7\3\7\3\7\5\7\u00e7\n\7\3\b\3\b\5\b\u00eb\n\b\3"+
-    "\t\3\t\5\t\u00ef\n\t\3\t\3\t\3\t\7\t\u00f4\n\t\f\t\16\t\u00f7\13\t\3\t"+
-    "\5\t\u00fa\n\t\3\t\3\t\5\t\u00fe\n\t\3\t\3\t\3\t\5\t\u0103\n\t\3\t\3\t"+
-    "\5\t\u0107\n\t\3\n\3\n\3\n\3\n\7\n\u010d\n\n\f\n\16\n\u0110\13\n\3\13"+
-    "\5\13\u0113\n\13\3\13\3\13\3\13\7\13\u0118\n\13\f\13\16\13\u011b\13\13"+
-    "\3\f\3\f\3\r\3\r\3\r\3\r\7\r\u0123\n\r\f\r\16\r\u0126\13\r\5\r\u0128\n"+
-    "\r\3\r\3\r\5\r\u012c\n\r\3\16\3\16\3\16\3\16\3\16\3\16\3\17\3\17\3\20"+
-    "\3\20\5\20\u0138\n\20\3\20\5\20\u013b\n\20\3\21\3\21\7\21\u013f\n\21\f"+
-    "\21\16\21\u0142\13\21\3\22\3\22\3\22\3\22\5\22\u0148\n\22\3\22\3\22\3"+
-    "\22\3\22\3\22\5\22\u014f\n\22\3\23\5\23\u0152\n\23\3\23\3\23\5\23\u0156"+
-    "\n\23\3\23\3\23\5\23\u015a\n\23\3\23\3\23\5\23\u015e\n\23\5\23\u0160\n"+
-    "\23\3\24\3\24\3\24\3\24\3\24\3\24\3\24\7\24\u0169\n\24\f\24\16\24\u016c"+
-    "\13\24\3\24\3\24\5\24\u0170\n\24\3\25\3\25\5\25\u0174\n\25\3\25\5\25\u0177"+
-    "\n\25\3\25\3\25\3\25\3\25\5\25\u017d\n\25\3\25\5\25\u0180\n\25\3\25\3"+
-    "\25\3\25\3\25\5\25\u0186\n\25\3\25\5\25\u0189\n\25\5\25\u018b\n\25\3\26"+
+    "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\3\2\3\2\3\2\3\3\3\3"+
+    "\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\7\4`\n\4\f\4\16\4c\13\4\3\4\5"+
+    "\4f\n\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\7\4o\n\4\f\4\16\4r\13\4\3\4\5\4u\n"+
+    "\4\3\4\3\4\3\4\3\4\5\4{\n\4\3\4\5\4~\n\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3"+
+    "\4\3\4\5\4\u0089\n\4\3\4\5\4\u008c\n\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4"+
+    "\5\4\u0096\n\4\3\4\5\4\u0099\n\4\3\4\5\4\u009c\n\4\3\4\5\4\u009f\n\4\3"+
+    "\4\3\4\3\4\3\4\7\4\u00a5\n\4\f\4\16\4\u00a8\13\4\5\4\u00aa\n\4\3\4\3\4"+
+    "\3\4\3\4\5\4\u00b0\n\4\3\4\3\4\5\4\u00b4\n\4\3\4\5\4\u00b7\n\4\3\4\5\4"+
+    "\u00ba\n\4\3\4\5\4\u00bd\n\4\3\4\3\4\3\4\3\4\3\4\5\4\u00c4\n\4\3\5\3\5"+
+    "\3\5\3\5\7\5\u00ca\n\5\f\5\16\5\u00cd\13\5\5\5\u00cf\n\5\3\5\3\5\3\6\3"+
+    "\6\3\6\3\6\3\6\3\6\7\6\u00d9\n\6\f\6\16\6\u00dc\13\6\5\6\u00de\n\6\3\6"+
+    "\3\6\5\6\u00e2\n\6\3\7\3\7\3\7\3\7\3\7\5\7\u00e9\n\7\3\b\3\b\5\b\u00ed"+
+    "\n\b\3\t\3\t\5\t\u00f1\n\t\3\t\3\t\3\t\7\t\u00f6\n\t\f\t\16\t\u00f9\13"+
+    "\t\3\t\5\t\u00fc\n\t\3\t\3\t\5\t\u0100\n\t\3\t\3\t\3\t\5\t\u0105\n\t\3"+
+    "\t\3\t\5\t\u0109\n\t\3\n\3\n\3\n\3\n\7\n\u010f\n\n\f\n\16\n\u0112\13\n"+
+    "\3\13\5\13\u0115\n\13\3\13\3\13\3\13\7\13\u011a\n\13\f\13\16\13\u011d"+
+    "\13\13\3\f\3\f\3\r\3\r\3\r\3\r\7\r\u0125\n\r\f\r\16\r\u0128\13\r\5\r\u012a"+
+    "\n\r\3\r\3\r\5\r\u012e\n\r\3\16\3\16\3\16\3\16\3\16\3\16\3\17\3\17\3\20"+
+    "\3\20\5\20\u013a\n\20\3\20\5\20\u013d\n\20\3\21\3\21\7\21\u0141\n\21\f"+
+    "\21\16\21\u0144\13\21\3\22\3\22\3\22\3\22\5\22\u014a\n\22\3\22\3\22\3"+
+    "\22\3\22\3\22\5\22\u0151\n\22\3\23\5\23\u0154\n\23\3\23\3\23\5\23\u0158"+
+    "\n\23\3\23\3\23\5\23\u015c\n\23\3\23\3\23\5\23\u0160\n\23\5\23\u0162\n"+
+    "\23\3\24\3\24\3\24\3\24\3\24\3\24\3\24\7\24\u016b\n\24\f\24\16\24\u016e"+
+    "\13\24\3\24\3\24\5\24\u0172\n\24\3\25\3\25\5\25\u0176\n\25\3\25\5\25\u0179"+
+    "\n\25\3\25\3\25\3\25\3\25\5\25\u017f\n\25\3\25\5\25\u0182\n\25\3\25\3"+
+    "\25\3\25\3\25\5\25\u0188\n\25\3\25\5\25\u018b\n\25\5\25\u018d\n\25\3\26"+
     "\3\26\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27"+
-    "\7\27\u019c\n\27\f\27\16\27\u019f\13\27\3\27\3\27\3\27\3\27\3\27\3\27"+
-    "\3\27\3\27\7\27\u01a9\n\27\f\27\16\27\u01ac\13\27\3\27\3\27\3\27\3\27"+
-    "\3\27\3\27\3\27\3\27\3\27\7\27\u01b7\n\27\f\27\16\27\u01ba\13\27\3\27"+
-    "\3\27\5\27\u01be\n\27\3\27\3\27\3\27\3\27\3\27\3\27\7\27\u01c6\n\27\f"+
-    "\27\16\27\u01c9\13\27\3\30\3\30\5\30\u01cd\n\30\3\31\5\31\u01d0\n\31\3"+
-    "\31\3\31\3\31\3\31\3\31\3\31\5\31\u01d8\n\31\3\31\3\31\3\31\3\31\3\31"+
-    "\7\31\u01df\n\31\f\31\16\31\u01e2\13\31\3\31\3\31\3\31\5\31\u01e7\n\31"+
-    "\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u01ef\n\31\3\31\3\31\3\31\5\31\u01f4"+
-    "\n\31\3\31\3\31\3\31\3\31\5\31\u01fa\n\31\3\31\5\31\u01fd\n\31\3\32\3"+
-    "\32\3\32\5\32\u0202\n\32\3\32\5\32\u0205\n\32\3\33\3\33\3\33\3\33\5\33"+
-    "\u020b\n\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\7\33\u0217"+
-    "\n\33\f\33\16\33\u021a\13\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3"+
-    "\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\5\34\u022f\n\34"+
-    "\3\34\3\34\3\34\3\34\5\34\u0235\n\34\3\34\3\34\3\34\7\34\u023a\n\34\f"+
-    "\34\16\34\u023d\13\34\5\34\u023f\n\34\3\34\3\34\3\34\3\34\3\34\3\34\3"+
-    "\34\3\34\3\34\3\34\3\34\3\34\5\34\u024d\n\34\3\35\3\35\3\35\3\35\6\35"+
-    "\u0253\n\35\r\35\16\35\u0254\3\35\5\35\u0258\n\35\3\36\3\36\3\37\3\37"+
-    "\3 \3 \3!\3!\3!\7!\u0263\n!\f!\16!\u0266\13!\3!\3!\3\"\3\"\5\"\u026c\n"+
-    "\"\3#\3#\3#\5#\u0271\n#\3#\3#\3#\3#\5#\u0277\n#\3#\5#\u027a\n#\3$\3$\5"+
-    "$\u027e\n$\3%\3%\3%\5%\u0283\n%\3&\3&\5&\u0287\n&\3\'\3\'\3\'\2\4,\64"+
-    "(\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDF"+
-    "HJL\2\20\b\2\7\7\t\t\31\31,,\62\62\66\66\4\2\"\"BB\4\2\t\t\62\62\4\2\37"+
-    "\37%%\3\2\25\26\3\2WX\4\2\7\7YY\4\2\r\r\25\25\4\2\7\7\27\27\3\2PQ\3\2"+
-    "RT\3\2JO\4\2\35\35CC\20\2\b\t\22\24\31\31\33\33\36\36!\",,\62\62\668:"+
-    "<>?ABDEGG\u02e7\2N\3\2\2\2\4Q\3\2\2\2\6\u00c1\3\2\2\2\b\u00cc\3\2\2\2"+
-    "\n\u00d0\3\2\2\2\f\u00e6\3\2\2\2\16\u00e8\3\2\2\2\20\u00ec\3\2\2\2\22"+
-    "\u0108\3\2\2\2\24\u0112\3\2\2\2\26\u011c\3\2\2\2\30\u012b\3\2\2\2\32\u012d"+
-    "\3\2\2\2\34\u0133\3\2\2\2\36\u0135\3\2\2\2 \u013c\3\2\2\2\"\u014e\3\2"+
-    "\2\2$\u015f\3\2\2\2&\u016f\3\2\2\2(\u018a\3\2\2\2*\u018c\3\2\2\2,\u01bd"+
-    "\3\2\2\2.\u01ca\3\2\2\2\60\u01fc\3\2\2\2\62\u0204\3\2\2\2\64\u020a\3\2"+
-    "\2\2\66\u024c\3\2\2\28\u0257\3\2\2\2:\u0259\3\2\2\2<\u025b\3\2\2\2>\u025d"+
-    "\3\2\2\2@\u0264\3\2\2\2B\u026b\3\2\2\2D\u0279\3\2\2\2F\u027d\3\2\2\2H"+
-    "\u0282\3\2\2\2J\u0286\3\2\2\2L\u0288\3\2\2\2NO\5\6\4\2OP\7\2\2\3P\3\3"+
-    "\2\2\2QR\5*\26\2RS\7\2\2\3S\5\3\2\2\2T\u00c2\5\b\5\2Uc\7\33\2\2V_\7\3"+
-    "\2\2WX\78\2\2X^\t\2\2\2YZ\7\36\2\2Z^\t\3\2\2[\\\7G\2\2\\^\5<\37\2]W\3"+
-    "\2\2\2]Y\3\2\2\2][\3\2\2\2^a\3\2\2\2_]\3\2\2\2_`\3\2\2\2`b\3\2\2\2a_\3"+
-    "\2\2\2bd\7\4\2\2cV\3\2\2\2cd\3\2\2\2de\3\2\2\2e\u00c2\5\6\4\2fr\7\24\2"+
-    "\2gn\7\3\2\2hi\78\2\2im\t\4\2\2jk\7\36\2\2km\t\3\2\2lh\3\2\2\2lj\3\2\2"+
-    "\2mp\3\2\2\2nl\3\2\2\2no\3\2\2\2oq\3\2\2\2pn\3\2\2\2qs\7\4\2\2rg\3\2\2"+
-    "\2rs\3\2\2\2st\3\2\2\2t\u00c2\5\6\4\2uv\7>\2\2v{\7A\2\2wy\7*\2\2xw\3\2"+
-    "\2\2xy\3\2\2\2yz\3\2\2\2z|\5\62\32\2{x\3\2\2\2{|\3\2\2\2|\u00c2\3\2\2"+
-    "\2}~\7>\2\2~\177\7\23\2\2\177\u0080\t\5\2\2\u0080\u00c2\5D#\2\u0081\u0082"+
-    "\t\6\2\2\u0082\u00c2\5D#\2\u0083\u0084\7>\2\2\u0084\u0089\7!\2\2\u0085"+
-    "\u0087\7*\2\2\u0086\u0085\3\2\2\2\u0086\u0087\3\2\2\2\u0087\u0088\3\2"+
-    "\2\2\u0088\u008a\5\62\32\2\u0089\u0086\3\2\2\2\u0089\u008a\3\2\2\2\u008a"+
-    "\u00c2\3\2\2\2\u008b\u008c\7>\2\2\u008c\u00c2\7<\2\2\u008d\u008e\7?\2"+
-    "\2\u008e\u00c2\7\22\2\2\u008f\u0090\7?\2\2\u0090\u0096\7A\2\2\u0091\u0093"+
-    "\7\21\2\2\u0092\u0094\7*\2\2\u0093\u0092\3\2\2\2\u0093\u0094\3\2\2\2\u0094"+
-    "\u0095\3\2\2\2\u0095\u0097\5\62\32\2\u0096\u0091\3\2\2\2\u0096\u0097\3"+
-    "\2\2\2\u0097\u009c\3\2\2\2\u0098\u009a\7*\2\2\u0099\u0098\3\2\2\2\u0099"+
-    "\u009a\3\2\2\2\u009a\u009b\3\2\2\2\u009b\u009d\5\62\32\2\u009c\u0099\3"+
-    "\2\2\2\u009c\u009d\3\2\2\2\u009d\u00a7\3\2\2\2\u009e\u009f\7D\2\2\u009f"+
-    "\u00a4\7X\2\2\u00a0\u00a1\7\5\2\2\u00a1\u00a3\7X\2\2\u00a2\u00a0\3\2\2"+
-    "\2\u00a3\u00a6\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\u00a8"+
-    "\3\2\2\2\u00a6\u00a4\3\2\2\2\u00a7\u009e\3\2\2\2\u00a7\u00a8\3\2\2\2\u00a8"+
-    "\u00c2\3\2\2\2\u00a9\u00aa\7?\2\2\u00aa\u00ad\7\23\2\2\u00ab\u00ac\7\21"+
-    "\2\2\u00ac\u00ae\t\7\2\2\u00ad\u00ab\3\2\2\2\u00ad\u00ae\3\2\2\2\u00ae"+
-    "\u00b4\3\2\2\2\u00af\u00b1\7@\2\2\u00b0\u00b2\7*\2\2\u00b1\u00b0\3\2\2"+
-    "\2\u00b1\u00b2\3\2\2\2\u00b2\u00b3\3\2\2\2\u00b3\u00b5\5\62\32\2\u00b4"+
-    "\u00af\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5\u00ba\3\2\2\2\u00b6\u00b8\7*"+
-    "\2\2\u00b7\u00b6\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9"+
-    "\u00bb\5\62\32\2\u00ba\u00b7\3\2\2\2\u00ba\u00bb\3\2\2\2\u00bb\u00c2\3"+
-    "\2\2\2\u00bc\u00bd\7?\2\2\u00bd\u00c2\7E\2\2\u00be\u00bf\7?\2\2\u00bf"+
-    "\u00c0\7@\2\2\u00c0\u00c2\7E\2\2\u00c1T\3\2\2\2\u00c1U\3\2\2\2\u00c1f"+
-    "\3\2\2\2\u00c1u\3\2\2\2\u00c1}\3\2\2\2\u00c1\u0081\3\2\2\2\u00c1\u0083"+
-    "\3\2\2\2\u00c1\u008b\3\2\2\2\u00c1\u008d\3\2\2\2\u00c1\u008f\3\2\2\2\u00c1"+
-    "\u00a9\3\2\2\2\u00c1\u00bc\3\2\2\2\u00c1\u00be\3\2\2\2\u00c2\7\3\2\2\2"+
-    "\u00c3\u00c4\7I\2\2\u00c4\u00c9\5\32\16\2\u00c5\u00c6\7\5\2\2\u00c6\u00c8"+
-    "\5\32\16\2\u00c7\u00c5\3\2\2\2\u00c8\u00cb\3\2\2\2\u00c9\u00c7\3\2\2\2"+
-    "\u00c9\u00ca\3\2\2\2\u00ca\u00cd\3\2\2\2\u00cb\u00c9\3\2\2\2\u00cc\u00c3"+
-    "\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00cf\5\n\6\2\u00cf"+
-    "\t\3\2\2\2\u00d0\u00db\5\f\7\2\u00d1\u00d2\7\64\2\2\u00d2\u00d3\7\17\2"+
-    "\2\u00d3\u00d8\5\16\b\2\u00d4\u00d5\7\5\2\2\u00d5\u00d7\5\16\b\2\u00d6"+
-    "\u00d4\3\2\2\2\u00d7\u00da\3\2\2\2\u00d8\u00d6\3\2\2\2\u00d8\u00d9\3\2"+
-    "\2\2\u00d9\u00dc\3\2\2\2\u00da\u00d8\3\2\2\2\u00db\u00d1\3\2\2\2\u00db"+
-    "\u00dc\3\2\2\2\u00dc\u00df\3\2\2\2\u00dd\u00de\7+\2\2\u00de\u00e0\t\b"+
-    "\2\2\u00df\u00dd\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\13\3\2\2\2\u00e1\u00e7"+
-    "\5\20\t\2\u00e2\u00e3\7\3\2\2\u00e3\u00e4\5\n\6\2\u00e4\u00e5\7\4\2\2"+
-    "\u00e5\u00e7\3\2\2\2\u00e6\u00e1\3\2\2\2\u00e6\u00e2\3\2\2\2\u00e7\r\3"+
-    "\2\2\2\u00e8\u00ea\5*\26\2\u00e9\u00eb\t\t\2\2\u00ea\u00e9\3\2\2\2\u00ea"+
-    "\u00eb\3\2\2\2\u00eb\17\3\2\2\2\u00ec\u00ee\7=\2\2\u00ed\u00ef\5\34\17"+
-    "\2\u00ee\u00ed\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f5"+
-    "\5\36\20\2\u00f1\u00f2\7\5\2\2\u00f2\u00f4\5\36\20\2\u00f3\u00f1\3\2\2"+
-    "\2\u00f4\u00f7\3\2\2\2\u00f5\u00f3\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6\u00f9"+
-    "\3\2\2\2\u00f7\u00f5\3\2\2\2\u00f8\u00fa\5\22\n\2\u00f9\u00f8\3\2\2\2"+
-    "\u00f9\u00fa\3\2\2\2\u00fa\u00fd\3\2\2\2\u00fb\u00fc\7H\2\2\u00fc\u00fe"+
-    "\5,\27\2\u00fd\u00fb\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe\u0102\3\2\2\2\u00ff"+
-    "\u0100\7#\2\2\u0100\u0101\7\17\2\2\u0101\u0103\5\24\13\2\u0102\u00ff\3"+
-    "\2\2\2\u0102\u0103\3\2\2\2\u0103\u0106\3\2\2\2\u0104\u0105\7$\2\2\u0105"+
-    "\u0107\5,\27\2\u0106\u0104\3\2\2\2\u0106\u0107\3\2\2\2\u0107\21\3\2\2"+
-    "\2\u0108\u0109\7\37\2\2\u0109\u010e\5 \21\2\u010a\u010b\7\5\2\2\u010b"+
-    "\u010d\5 \21\2\u010c\u010a\3\2\2\2\u010d\u0110\3\2\2\2\u010e\u010c\3\2"+
-    "\2\2\u010e\u010f\3\2\2\2\u010f\23\3\2\2\2\u0110\u010e\3\2\2\2\u0111\u0113"+
-    "\5\34\17\2\u0112\u0111\3\2\2\2\u0112\u0113\3\2\2\2\u0113\u0114\3\2\2\2"+
-    "\u0114\u0119\5\26\f\2\u0115\u0116\7\5\2\2\u0116\u0118\5\26\f\2\u0117\u0115"+
-    "\3\2\2\2\u0118\u011b\3\2\2\2\u0119\u0117\3\2\2\2\u0119\u011a\3\2\2\2\u011a"+
-    "\25\3\2\2\2\u011b\u0119\3\2\2\2\u011c\u011d\5\30\r\2\u011d\27\3\2\2\2"+
-    "\u011e\u0127\7\3\2\2\u011f\u0124\5*\26\2\u0120\u0121\7\5\2\2\u0121\u0123"+
-    "\5*\26\2\u0122\u0120\3\2\2\2\u0123\u0126\3\2\2\2\u0124\u0122\3\2\2\2\u0124"+
-    "\u0125\3\2\2\2\u0125\u0128\3\2\2\2\u0126\u0124\3\2\2\2\u0127\u011f\3\2"+
-    "\2\2\u0127\u0128\3\2\2\2\u0128\u0129\3\2\2\2\u0129\u012c\7\4\2\2\u012a"+
-    "\u012c\5*\26\2\u012b\u011e\3\2\2\2\u012b\u012a\3\2\2\2\u012c\31\3\2\2"+
-    "\2\u012d\u012e\5B\"\2\u012e\u012f\7\f\2\2\u012f\u0130\7\3\2\2\u0130\u0131"+
-    "\5\n\6\2\u0131\u0132\7\4\2\2\u0132\33\3\2\2\2\u0133\u0134\t\n\2\2\u0134"+
-    "\35\3\2\2\2\u0135\u013a\5*\26\2\u0136\u0138\7\f\2\2\u0137\u0136\3\2\2"+
-    "\2\u0137\u0138\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013b\5B\"\2\u013a\u0137"+
-    "\3\2\2\2\u013a\u013b\3\2\2\2\u013b\37\3\2\2\2\u013c\u0140\5(\25\2\u013d"+
-    "\u013f\5\"\22\2\u013e\u013d\3\2\2\2\u013f\u0142\3\2\2\2\u0140\u013e\3"+
-    "\2\2\2\u0140\u0141\3\2\2\2\u0141!\3\2\2\2\u0142\u0140\3\2\2\2\u0143\u0144"+
-    "\5$\23\2\u0144\u0145\7(\2\2\u0145\u0147\5(\25\2\u0146\u0148\5&\24\2\u0147"+
-    "\u0146\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014f\3\2\2\2\u0149\u014a\7."+
-    "\2\2\u014a\u014b\5$\23\2\u014b\u014c\7(\2\2\u014c\u014d\5(\25\2\u014d"+
-    "\u014f\3\2\2\2\u014e\u0143\3\2\2\2\u014e\u0149\3\2\2\2\u014f#\3\2\2\2"+
-    "\u0150\u0152\7&\2\2\u0151\u0150\3\2\2\2\u0151\u0152\3\2\2\2\u0152\u0160"+
-    "\3\2\2\2\u0153\u0155\7)\2\2\u0154\u0156\7\65\2\2\u0155\u0154\3\2\2\2\u0155"+
-    "\u0156\3\2\2\2\u0156\u0160\3\2\2\2\u0157\u0159\79\2\2\u0158\u015a\7\65"+
-    "\2\2\u0159\u0158\3\2\2\2\u0159\u015a\3\2\2\2\u015a\u0160\3\2\2\2\u015b"+
-    "\u015d\7 \2\2\u015c\u015e\7\65\2\2\u015d\u015c\3\2\2\2\u015d\u015e\3\2"+
-    "\2\2\u015e\u0160\3\2\2\2\u015f\u0151\3\2\2\2\u015f\u0153\3\2\2\2\u015f"+
-    "\u0157\3\2\2\2\u015f\u015b\3\2\2\2\u0160%\3\2\2\2\u0161\u0162\7\61\2\2"+
-    "\u0162\u0170\5,\27\2\u0163\u0164\7F\2\2\u0164\u0165\7\3\2\2\u0165\u016a"+
-    "\5B\"\2\u0166\u0167\7\5\2\2\u0167\u0169\5B\"\2\u0168\u0166\3\2\2\2\u0169"+
-    "\u016c\3\2\2\2\u016a\u0168\3\2\2\2\u016a\u016b\3\2\2\2\u016b\u016d\3\2"+
-    "\2\2\u016c\u016a\3\2\2\2\u016d\u016e\7\4\2\2\u016e\u0170\3\2\2\2\u016f"+
-    "\u0161\3\2\2\2\u016f\u0163\3\2\2\2\u0170\'\3\2\2\2\u0171\u0176\5D#\2\u0172"+
-    "\u0174\7\f\2\2\u0173\u0172\3\2\2\2\u0173\u0174\3\2\2\2\u0174\u0175\3\2"+
-    "\2\2\u0175\u0177\5@!\2\u0176\u0173\3\2\2\2\u0176\u0177\3\2\2\2\u0177\u018b"+
-    "\3\2\2\2\u0178\u0179\7\3\2\2\u0179\u017a\5\n\6\2\u017a\u017f\7\4\2\2\u017b"+
-    "\u017d\7\f\2\2\u017c\u017b\3\2\2\2\u017c\u017d\3\2\2\2\u017d\u017e\3\2"+
-    "\2\2\u017e\u0180\5@!\2\u017f\u017c\3\2\2\2\u017f\u0180\3\2\2\2\u0180\u018b"+
-    "\3\2\2\2\u0181\u0182\7\3\2\2\u0182\u0183\5 \21\2\u0183\u0188\7\4\2\2\u0184"+
-    "\u0186\7\f\2\2\u0185\u0184\3\2\2\2\u0185\u0186\3\2\2\2\u0186\u0187\3\2"+
-    "\2\2\u0187\u0189\5@!\2\u0188\u0185\3\2\2\2\u0188\u0189\3\2\2\2\u0189\u018b"+
-    "\3\2\2\2\u018a\u0171\3\2\2\2\u018a\u0178\3\2\2\2\u018a\u0181\3\2\2\2\u018b"+
-    ")\3\2\2\2\u018c\u018d\5,\27\2\u018d+\3\2\2\2\u018e\u018f\b\27\1\2\u018f"+
-    "\u0190\7/\2\2\u0190\u01be\5,\27\n\u0191\u0192\7\32\2\2\u0192\u0193\7\3"+
-    "\2\2\u0193\u0194\5\b\5\2\u0194\u0195\7\4\2\2\u0195\u01be\3\2\2\2\u0196"+
-    "\u0197\7;\2\2\u0197\u0198\7\3\2\2\u0198\u019d\7X\2\2\u0199\u019a\7\5\2"+
-    "\2\u019a\u019c\7X\2\2\u019b\u0199\3\2\2\2\u019c\u019f\3\2\2\2\u019d\u019b"+
-    "\3\2\2\2\u019d\u019e\3\2\2\2\u019e\u01a0\3\2\2\2\u019f\u019d\3\2\2\2\u01a0"+
-    "\u01be\7\4\2\2\u01a1\u01a2\7-\2\2\u01a2\u01a3\7\3\2\2\u01a3\u01a4\5@!"+
-    "\2\u01a4\u01a5\7\5\2\2\u01a5\u01aa\7X\2\2\u01a6\u01a7\7\5\2\2\u01a7\u01a9"+
-    "\7X\2\2\u01a8\u01a6\3\2\2\2\u01a9\u01ac\3\2\2\2\u01aa\u01a8\3\2\2\2\u01aa"+
-    "\u01ab\3\2\2\2\u01ab\u01ad\3\2\2\2\u01ac\u01aa\3\2\2\2\u01ad\u01ae\7\4"+
-    "\2\2\u01ae\u01be\3\2\2\2\u01af\u01b0\7-\2\2\u01b0\u01b1\7\3\2\2\u01b1"+
-    "\u01b2\7X\2\2\u01b2\u01b3\7\5\2\2\u01b3\u01b8\7X\2\2\u01b4\u01b5\7\5\2"+
-    "\2\u01b5\u01b7\7X\2\2\u01b6\u01b4\3\2\2\2\u01b7\u01ba\3\2\2\2\u01b8\u01b6"+
-    "\3\2\2\2\u01b8\u01b9\3\2\2\2\u01b9\u01bb\3\2\2\2\u01ba\u01b8\3\2\2\2\u01bb"+
-    "\u01be\7\4\2\2\u01bc\u01be\5.\30\2\u01bd\u018e\3\2\2\2\u01bd\u0191\3\2"+
-    "\2\2\u01bd\u0196\3\2\2\2\u01bd\u01a1\3\2\2\2\u01bd\u01af\3\2\2\2\u01bd"+
-    "\u01bc\3\2\2\2\u01be\u01c7\3\2\2\2\u01bf\u01c0\f\4\2\2\u01c0\u01c1\7\n"+
-    "\2\2\u01c1\u01c6\5,\27\5\u01c2\u01c3\f\3\2\2\u01c3\u01c4\7\63\2\2\u01c4"+
-    "\u01c6\5,\27\4\u01c5\u01bf\3\2\2\2\u01c5\u01c2\3\2\2\2\u01c6\u01c9\3\2"+
-    "\2\2\u01c7\u01c5\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8-\3\2\2\2\u01c9\u01c7"+
-    "\3\2\2\2\u01ca\u01cc\5\64\33\2\u01cb\u01cd\5\60\31\2\u01cc\u01cb\3\2\2"+
-    "\2\u01cc\u01cd\3\2\2\2\u01cd/\3\2\2\2\u01ce\u01d0\7/\2\2\u01cf\u01ce\3"+
-    "\2\2\2\u01cf\u01d0\3\2\2\2\u01d0\u01d1\3\2\2\2\u01d1\u01d2\7\16\2\2\u01d2"+
-    "\u01d3\5\64\33\2\u01d3\u01d4\7\n\2\2\u01d4\u01d5\5\64\33\2\u01d5\u01fd"+
-    "\3\2\2\2\u01d6\u01d8\7/\2\2\u01d7\u01d6\3\2\2\2\u01d7\u01d8\3\2\2\2\u01d8"+
-    "\u01d9\3\2\2\2\u01d9\u01da\7%\2\2\u01da\u01db\7\3\2\2\u01db\u01e0\5*\26"+
-    "\2\u01dc\u01dd\7\5\2\2\u01dd\u01df\5*\26\2\u01de\u01dc\3\2\2\2\u01df\u01e2"+
-    "\3\2\2\2\u01e0\u01de\3\2\2\2\u01e0\u01e1\3\2\2\2\u01e1\u01e3\3\2\2\2\u01e2"+
-    "\u01e0\3\2\2\2\u01e3\u01e4\7\4\2\2\u01e4\u01fd\3\2\2\2\u01e5\u01e7\7/"+
-    "\2\2\u01e6\u01e5\3\2\2\2\u01e6\u01e7\3\2\2\2\u01e7\u01e8\3\2\2\2\u01e8"+
-    "\u01e9\7%\2\2\u01e9\u01ea\7\3\2\2\u01ea\u01eb\5\b\5\2\u01eb\u01ec\7\4"+
-    "\2\2\u01ec\u01fd\3\2\2\2\u01ed\u01ef\7/\2\2\u01ee\u01ed\3\2\2\2\u01ee"+
-    "\u01ef\3\2\2\2\u01ef\u01f0\3\2\2\2\u01f0\u01f1\7*\2\2\u01f1\u01fd\5\62"+
-    "\32\2\u01f2\u01f4\7/\2\2\u01f3\u01f2\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4"+
-    "\u01f5\3\2\2\2\u01f5\u01f6\7:\2\2\u01f6\u01fd\7X\2\2\u01f7\u01f9\7\'\2"+
-    "\2\u01f8\u01fa\7/\2\2\u01f9\u01f8\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fa\u01fb"+
-    "\3\2\2\2\u01fb\u01fd\7\60\2\2\u01fc\u01cf\3\2\2\2\u01fc\u01d7\3\2\2\2"+
-    "\u01fc\u01e6\3\2\2\2\u01fc\u01ee\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f7"+
-    "\3\2\2\2\u01fd\61\3\2\2\2\u01fe\u0201\7X\2\2\u01ff\u0200\7\30\2\2\u0200"+
-    "\u0202\7X\2\2\u0201\u01ff\3\2\2\2\u0201\u0202\3\2\2\2\u0202\u0205\3\2"+
-    "\2\2\u0203\u0205\7W\2\2\u0204\u01fe\3\2\2\2\u0204\u0203\3\2\2\2\u0205"+
-    "\63\3\2\2\2\u0206\u0207\b\33\1\2\u0207\u020b\5\66\34\2\u0208\u0209\t\13"+
-    "\2\2\u0209\u020b\5\64\33\6\u020a\u0206\3\2\2\2\u020a\u0208\3\2\2\2\u020b"+
-    "\u0218\3\2\2\2\u020c\u020d\f\5\2\2\u020d\u020e\t\f\2\2\u020e\u0217\5\64"+
-    "\33\6\u020f\u0210\f\4\2\2\u0210\u0211\t\13\2\2\u0211\u0217\5\64\33\5\u0212"+
-    "\u0213\f\3\2\2\u0213\u0214\5:\36\2\u0214\u0215\5\64\33\4\u0215\u0217\3"+
-    "\2\2\2\u0216\u020c\3\2\2\2\u0216\u020f\3\2\2\2\u0216\u0212\3\2\2\2\u0217"+
-    "\u021a\3\2\2\2\u0218\u0216\3\2\2\2\u0218\u0219\3\2\2\2\u0219\65\3\2\2"+
-    "\2\u021a\u0218\3\2\2\2\u021b\u021c\7\20\2\2\u021c\u021d\7\3\2\2\u021d"+
-    "\u021e\5*\26\2\u021e\u021f\7\f\2\2\u021f\u0220\5> \2\u0220\u0221\7\4\2"+
-    "\2\u0221\u024d\3\2\2\2\u0222\u0223\7\34\2\2\u0223\u0224\7\3\2\2\u0224"+
-    "\u0225\5B\"\2\u0225\u0226\7\37\2\2\u0226\u0227\5\64\33\2\u0227\u0228\7"+
-    "\4\2\2\u0228\u024d\3\2\2\2\u0229\u024d\58\35\2\u022a\u024d\7R\2\2\u022b"+
-    "\u022c\5@!\2\u022c\u022d\7V\2\2\u022d\u022f\3\2\2\2\u022e\u022b\3\2\2"+
-    "\2\u022e\u022f\3\2\2\2\u022f\u0230\3\2\2\2\u0230\u024d\7R\2\2\u0231\u0232"+
-    "\5B\"\2\u0232\u023e\7\3\2\2\u0233\u0235\5\34\17\2\u0234\u0233\3\2\2\2"+
-    "\u0234\u0235\3\2\2\2\u0235\u0236\3\2\2\2\u0236\u023b\5*\26\2\u0237\u0238"+
-    "\7\5\2\2\u0238\u023a\5*\26\2\u0239\u0237\3\2\2\2\u023a\u023d\3\2\2\2\u023b"+
-    "\u0239\3\2\2\2\u023b\u023c\3\2\2\2\u023c\u023f\3\2\2\2\u023d\u023b\3\2"+
-    "\2\2\u023e\u0234\3\2\2\2\u023e\u023f\3\2\2\2\u023f\u0240\3\2\2\2\u0240"+
-    "\u0241\7\4\2\2\u0241\u024d\3\2\2\2\u0242\u0243\7\3\2\2\u0243\u0244\5\b"+
-    "\5\2\u0244\u0245\7\4\2\2\u0245\u024d\3\2\2\2\u0246\u024d\5B\"\2\u0247"+
-    "\u024d\5@!\2\u0248\u0249\7\3\2\2\u0249\u024a\5*\26\2\u024a\u024b\7\4\2"+
-    "\2\u024b\u024d\3\2\2\2\u024c\u021b\3\2\2\2\u024c\u0222\3\2\2\2\u024c\u0229"+
-    "\3\2\2\2\u024c\u022a\3\2\2\2\u024c\u022e\3\2\2\2\u024c\u0231\3\2\2\2\u024c"+
-    "\u0242\3\2\2\2\u024c\u0246\3\2\2\2\u024c\u0247\3\2\2\2\u024c\u0248\3\2"+
-    "\2\2\u024d\67\3\2\2\2\u024e\u0258\7\60\2\2\u024f\u0258\5J&\2\u0250\u0258"+
-    "\5<\37\2\u0251\u0253\7X\2\2\u0252\u0251\3\2\2\2\u0253\u0254\3\2\2\2\u0254"+
-    "\u0252\3\2\2\2\u0254\u0255\3\2\2\2\u0255\u0258\3\2\2\2\u0256\u0258\7W"+
-    "\2\2\u0257\u024e\3\2\2\2\u0257\u024f\3\2\2\2\u0257\u0250\3\2\2\2\u0257"+
-    "\u0252\3\2\2\2\u0257\u0256\3\2\2\2\u02589\3\2\2\2\u0259\u025a\t\r\2\2"+
-    "\u025a;\3\2\2\2\u025b\u025c\t\16\2\2\u025c=\3\2\2\2\u025d\u025e\5B\"\2"+
-    "\u025e?\3\2\2\2\u025f\u0260\5B\"\2\u0260\u0261\7V\2\2\u0261\u0263\3\2"+
-    "\2\2\u0262\u025f\3\2\2\2\u0263\u0266\3\2\2\2\u0264\u0262\3\2\2\2\u0264"+
-    "\u0265\3\2\2\2\u0265\u0267\3\2\2\2\u0266\u0264\3\2\2\2\u0267\u0268\5B"+
-    "\"\2\u0268A\3\2\2\2\u0269\u026c\5F$\2\u026a\u026c\5H%\2\u026b\u0269\3"+
-    "\2\2\2\u026b\u026a\3\2\2\2\u026cC\3\2\2\2\u026d\u026e\5B\"\2\u026e\u026f"+
-    "\7\6\2\2\u026f\u0271\3\2\2\2\u0270\u026d\3\2\2\2\u0270\u0271\3\2\2\2\u0271"+
-    "\u0272\3\2\2\2\u0272\u027a\7]\2\2\u0273\u0274\5B\"\2\u0274\u0275\7\6\2"+
-    "\2\u0275\u0277\3\2\2\2\u0276\u0273\3\2\2\2\u0276\u0277\3\2\2\2\u0277\u0278"+
-    "\3\2\2\2\u0278\u027a\5B\"\2\u0279\u0270\3\2\2\2\u0279\u0276\3\2\2\2\u027a"+
-    "E\3\2\2\2\u027b\u027e\7^\2\2\u027c\u027e\7_\2\2\u027d\u027b\3\2\2\2\u027d"+
-    "\u027c\3\2\2\2\u027eG\3\2\2\2\u027f\u0283\7[\2\2\u0280\u0283\5L\'\2\u0281"+
-    "\u0283\7\\\2\2\u0282\u027f\3\2\2\2\u0282\u0280\3\2\2\2\u0282\u0281\3\2"+
-    "\2\2\u0283I\3\2\2\2\u0284\u0287\7Z\2\2\u0285\u0287\7Y\2\2\u0286\u0284"+
-    "\3\2\2\2\u0286\u0285\3\2\2\2\u0287K\3\2\2\2\u0288\u0289\t\17\2\2\u0289"+
-    "M\3\2\2\2a]_clnrx{\u0086\u0089\u0093\u0096\u0099\u009c\u00a4\u00a7\u00ad"+
-    "\u00b1\u00b4\u00b7\u00ba\u00c1\u00c9\u00cc\u00d8\u00db\u00df\u00e6\u00ea"+
-    "\u00ee\u00f5\u00f9\u00fd\u0102\u0106\u010e\u0112\u0119\u0124\u0127\u012b"+
-    "\u0137\u013a\u0140\u0147\u014e\u0151\u0155\u0159\u015d\u015f\u016a\u016f"+
-    "\u0173\u0176\u017c\u017f\u0185\u0188\u018a\u019d\u01aa\u01b8\u01bd\u01c5"+
-    "\u01c7\u01cc\u01cf\u01d7\u01e0\u01e6\u01ee\u01f3\u01f9\u01fc\u0201\u0204"+
-    "\u020a\u0216\u0218\u022e\u0234\u023b\u023e\u024c\u0254\u0257\u0264\u026b"+
-    "\u0270\u0276\u0279\u027d\u0282\u0286";
+    "\7\27\u019e\n\27\f\27\16\27\u01a1\13\27\3\27\3\27\3\27\3\27\3\27\3\27"+
+    "\3\27\3\27\3\27\7\27\u01ac\n\27\f\27\16\27\u01af\13\27\3\27\3\27\3\27"+
+    "\3\27\3\27\3\27\3\27\3\27\3\27\7\27\u01ba\n\27\f\27\16\27\u01bd\13\27"+
+    "\3\27\3\27\3\27\5\27\u01c2\n\27\3\27\3\27\3\27\3\27\3\27\3\27\7\27\u01ca"+
+    "\n\27\f\27\16\27\u01cd\13\27\3\30\3\30\5\30\u01d1\n\30\3\31\5\31\u01d4"+
+    "\n\31\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u01dc\n\31\3\31\3\31\3\31\3\31"+
+    "\3\31\7\31\u01e3\n\31\f\31\16\31\u01e6\13\31\3\31\3\31\3\31\5\31\u01eb"+
+    "\n\31\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u01f3\n\31\3\31\3\31\3\31\5\31"+
+    "\u01f8\n\31\3\31\3\31\3\31\3\31\5\31\u01fe\n\31\3\31\5\31\u0201\n\31\3"+
+    "\32\3\32\3\32\5\32\u0206\n\32\3\33\3\33\3\33\3\33\5\33\u020c\n\33\3\33"+
+    "\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\7\33\u0218\n\33\f\33\16"+
+    "\33\u021b\13\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34"+
+    "\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\5\34\u0230\n\34\3\34\3\34\3\34"+
+    "\3\34\5\34\u0236\n\34\3\34\3\34\3\34\7\34\u023b\n\34\f\34\16\34\u023e"+
+    "\13\34\5\34\u0240\n\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3"+
+    "\34\3\34\3\34\5\34\u024e\n\34\3\35\3\35\3\35\3\35\6\35\u0254\n\35\r\35"+
+    "\16\35\u0255\3\35\5\35\u0259\n\35\3\36\3\36\3\37\3\37\3 \3 \3!\3!\3!\7"+
+    "!\u0264\n!\f!\16!\u0267\13!\3!\3!\3\"\3\"\5\"\u026d\n\"\3#\3#\3#\5#\u0272"+
+    "\n#\3#\3#\3#\3#\5#\u0278\n#\3#\5#\u027b\n#\3$\3$\5$\u027f\n$\3%\3%\3%"+
+    "\5%\u0284\n%\3&\3&\5&\u0288\n&\3\'\3\'\3(\3(\3(\2\4,\64)\2\4\6\b\n\f\16"+
+    "\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLN\2\20\b\2\7\7"+
+    "\t\t\31\31,,\62\62\66\66\4\2\"\"BB\4\2\t\t\62\62\4\2\37\37%%\3\2\25\26"+
+    "\4\2\7\7YY\4\2\r\r\25\25\4\2\7\7\27\27\3\2PQ\3\2RT\3\2JO\4\2\35\35CC\3"+
+    "\2WX\20\2\b\t\22\24\31\31\33\33\36\36!\",,\62\62\668:<>?ABDEGG\u02e8\2"+
+    "P\3\2\2\2\4S\3\2\2\2\6\u00c3\3\2\2\2\b\u00ce\3\2\2\2\n\u00d2\3\2\2\2\f"+
+    "\u00e8\3\2\2\2\16\u00ea\3\2\2\2\20\u00ee\3\2\2\2\22\u010a\3\2\2\2\24\u0114"+
+    "\3\2\2\2\26\u011e\3\2\2\2\30\u012d\3\2\2\2\32\u012f\3\2\2\2\34\u0135\3"+
+    "\2\2\2\36\u0137\3\2\2\2 \u013e\3\2\2\2\"\u0150\3\2\2\2$\u0161\3\2\2\2"+
+    "&\u0171\3\2\2\2(\u018c\3\2\2\2*\u018e\3\2\2\2,\u01c1\3\2\2\2.\u01ce\3"+
+    "\2\2\2\60\u0200\3\2\2\2\62\u0202\3\2\2\2\64\u020b\3\2\2\2\66\u024d\3\2"+
+    "\2\28\u0258\3\2\2\2:\u025a\3\2\2\2<\u025c\3\2\2\2>\u025e\3\2\2\2@\u0265"+
+    "\3\2\2\2B\u026c\3\2\2\2D\u027a\3\2\2\2F\u027e\3\2\2\2H\u0283\3\2\2\2J"+
+    "\u0287\3\2\2\2L\u0289\3\2\2\2N\u028b\3\2\2\2PQ\5\6\4\2QR\7\2\2\3R\3\3"+
+    "\2\2\2ST\5*\26\2TU\7\2\2\3U\5\3\2\2\2V\u00c4\5\b\5\2We\7\33\2\2Xa\7\3"+
+    "\2\2YZ\78\2\2Z`\t\2\2\2[\\\7\36\2\2\\`\t\3\2\2]^\7G\2\2^`\5<\37\2_Y\3"+
+    "\2\2\2_[\3\2\2\2_]\3\2\2\2`c\3\2\2\2a_\3\2\2\2ab\3\2\2\2bd\3\2\2\2ca\3"+
+    "\2\2\2df\7\4\2\2eX\3\2\2\2ef\3\2\2\2fg\3\2\2\2g\u00c4\5\6\4\2ht\7\24\2"+
+    "\2ip\7\3\2\2jk\78\2\2ko\t\4\2\2lm\7\36\2\2mo\t\3\2\2nj\3\2\2\2nl\3\2\2"+
+    "\2or\3\2\2\2pn\3\2\2\2pq\3\2\2\2qs\3\2\2\2rp\3\2\2\2su\7\4\2\2ti\3\2\2"+
+    "\2tu\3\2\2\2uv\3\2\2\2v\u00c4\5\6\4\2wx\7>\2\2x}\7A\2\2y{\7*\2\2zy\3\2"+
+    "\2\2z{\3\2\2\2{|\3\2\2\2|~\5\62\32\2}z\3\2\2\2}~\3\2\2\2~\u00c4\3\2\2"+
+    "\2\177\u0080\7>\2\2\u0080\u0081\7\23\2\2\u0081\u0082\t\5\2\2\u0082\u00c4"+
+    "\5D#\2\u0083\u0084\t\6\2\2\u0084\u00c4\5D#\2\u0085\u0086\7>\2\2\u0086"+
+    "\u008b\7!\2\2\u0087\u0089\7*\2\2\u0088\u0087\3\2\2\2\u0088\u0089\3\2\2"+
+    "\2\u0089\u008a\3\2\2\2\u008a\u008c\5\62\32\2\u008b\u0088\3\2\2\2\u008b"+
+    "\u008c\3\2\2\2\u008c\u00c4\3\2\2\2\u008d\u008e\7>\2\2\u008e\u00c4\7<\2"+
+    "\2\u008f\u0090\7?\2\2\u0090\u00c4\7\22\2\2\u0091\u0092\7?\2\2\u0092\u0098"+
+    "\7A\2\2\u0093\u0095\7\21\2\2\u0094\u0096\7*\2\2\u0095\u0094\3\2\2\2\u0095"+
+    "\u0096\3\2\2\2\u0096\u0097\3\2\2\2\u0097\u0099\5\62\32\2\u0098\u0093\3"+
+    "\2\2\2\u0098\u0099\3\2\2\2\u0099\u009e\3\2\2\2\u009a\u009c\7*\2\2\u009b"+
+    "\u009a\3\2\2\2\u009b\u009c\3\2\2\2\u009c\u009d\3\2\2\2\u009d\u009f\5\62"+
+    "\32\2\u009e\u009b\3\2\2\2\u009e\u009f\3\2\2\2\u009f\u00a9\3\2\2\2\u00a0"+
+    "\u00a1\7D\2\2\u00a1\u00a6\5L\'\2\u00a2\u00a3\7\5\2\2\u00a3\u00a5\5L\'"+
+    "\2\u00a4\u00a2\3\2\2\2\u00a5\u00a8\3\2\2\2\u00a6\u00a4\3\2\2\2\u00a6\u00a7"+
+    "\3\2\2\2\u00a7\u00aa\3\2\2\2\u00a8\u00a6\3\2\2\2\u00a9\u00a0\3\2\2\2\u00a9"+
+    "\u00aa\3\2\2\2\u00aa\u00c4\3\2\2\2\u00ab\u00ac\7?\2\2\u00ac\u00af\7\23"+
+    "\2\2\u00ad\u00ae\7\21\2\2\u00ae\u00b0\5L\'\2\u00af\u00ad\3\2\2\2\u00af"+
+    "\u00b0\3\2\2\2\u00b0\u00b6\3\2\2\2\u00b1\u00b3\7@\2\2\u00b2\u00b4\7*\2"+
+    "\2\u00b3\u00b2\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5\u00b7"+
+    "\5\62\32\2\u00b6\u00b1\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7\u00bc\3\2\2\2"+
+    "\u00b8\u00ba\7*\2\2\u00b9\u00b8\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bb"+
+    "\3\2\2\2\u00bb\u00bd\5\62\32\2\u00bc\u00b9\3\2\2\2\u00bc\u00bd\3\2\2\2"+
+    "\u00bd\u00c4\3\2\2\2\u00be\u00bf\7?\2\2\u00bf\u00c4\7E\2\2\u00c0\u00c1"+
+    "\7?\2\2\u00c1\u00c2\7@\2\2\u00c2\u00c4\7E\2\2\u00c3V\3\2\2\2\u00c3W\3"+
+    "\2\2\2\u00c3h\3\2\2\2\u00c3w\3\2\2\2\u00c3\177\3\2\2\2\u00c3\u0083\3\2"+
+    "\2\2\u00c3\u0085\3\2\2\2\u00c3\u008d\3\2\2\2\u00c3\u008f\3\2\2\2\u00c3"+
+    "\u0091\3\2\2\2\u00c3\u00ab\3\2\2\2\u00c3\u00be\3\2\2\2\u00c3\u00c0\3\2"+
+    "\2\2\u00c4\7\3\2\2\2\u00c5\u00c6\7I\2\2\u00c6\u00cb\5\32\16\2\u00c7\u00c8"+
+    "\7\5\2\2\u00c8\u00ca\5\32\16\2\u00c9\u00c7\3\2\2\2\u00ca\u00cd\3\2\2\2"+
+    "\u00cb\u00c9\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00cf\3\2\2\2\u00cd\u00cb"+
+    "\3\2\2\2\u00ce\u00c5\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00d0\3\2\2\2\u00d0"+
+    "\u00d1\5\n\6\2\u00d1\t\3\2\2\2\u00d2\u00dd\5\f\7\2\u00d3\u00d4\7\64\2"+
+    "\2\u00d4\u00d5\7\17\2\2\u00d5\u00da\5\16\b\2\u00d6\u00d7\7\5\2\2\u00d7"+
+    "\u00d9\5\16\b\2\u00d8\u00d6\3\2\2\2\u00d9\u00dc\3\2\2\2\u00da\u00d8\3"+
+    "\2\2\2\u00da\u00db\3\2\2\2\u00db\u00de\3\2\2\2\u00dc\u00da\3\2\2\2\u00dd"+
+    "\u00d3\3\2\2\2\u00dd\u00de\3\2\2\2\u00de\u00e1\3\2\2\2\u00df\u00e0\7+"+
+    "\2\2\u00e0\u00e2\t\7\2\2\u00e1\u00df\3\2\2\2\u00e1\u00e2\3\2\2\2\u00e2"+
+    "\13\3\2\2\2\u00e3\u00e9\5\20\t\2\u00e4\u00e5\7\3\2\2\u00e5\u00e6\5\n\6"+
+    "\2\u00e6\u00e7\7\4\2\2\u00e7\u00e9\3\2\2\2\u00e8\u00e3\3\2\2\2\u00e8\u00e4"+
+    "\3\2\2\2\u00e9\r\3\2\2\2\u00ea\u00ec\5*\26\2\u00eb\u00ed\t\b\2\2\u00ec"+
+    "\u00eb\3\2\2\2\u00ec\u00ed\3\2\2\2\u00ed\17\3\2\2\2\u00ee\u00f0\7=\2\2"+
+    "\u00ef\u00f1\5\34\17\2\u00f0\u00ef\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f2"+
+    "\3\2\2\2\u00f2\u00f7\5\36\20\2\u00f3\u00f4\7\5\2\2\u00f4\u00f6\5\36\20"+
+    "\2\u00f5\u00f3\3\2\2\2\u00f6\u00f9\3\2\2\2\u00f7\u00f5\3\2\2\2\u00f7\u00f8"+
+    "\3\2\2\2\u00f8\u00fb\3\2\2\2\u00f9\u00f7\3\2\2\2\u00fa\u00fc\5\22\n\2"+
+    "\u00fb\u00fa\3\2\2\2\u00fb\u00fc\3\2\2\2\u00fc\u00ff\3\2\2\2\u00fd\u00fe"+
+    "\7H\2\2\u00fe\u0100\5,\27\2\u00ff\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2\u0100"+
+    "\u0104\3\2\2\2\u0101\u0102\7#\2\2\u0102\u0103\7\17\2\2\u0103\u0105\5\24"+
+    "\13\2\u0104\u0101\3\2\2\2\u0104\u0105\3\2\2\2\u0105\u0108\3\2\2\2\u0106"+
+    "\u0107\7$\2\2\u0107\u0109\5,\27\2\u0108\u0106\3\2\2\2\u0108\u0109\3\2"+
+    "\2\2\u0109\21\3\2\2\2\u010a\u010b\7\37\2\2\u010b\u0110\5 \21\2\u010c\u010d"+
+    "\7\5\2\2\u010d\u010f\5 \21\2\u010e\u010c\3\2\2\2\u010f\u0112\3\2\2\2\u0110"+
+    "\u010e\3\2\2\2\u0110\u0111\3\2\2\2\u0111\23\3\2\2\2\u0112\u0110\3\2\2"+
+    "\2\u0113\u0115\5\34\17\2\u0114\u0113\3\2\2\2\u0114\u0115\3\2\2\2\u0115"+
+    "\u0116\3\2\2\2\u0116\u011b\5\26\f\2\u0117\u0118\7\5\2\2\u0118\u011a\5"+
+    "\26\f\2\u0119\u0117\3\2\2\2\u011a\u011d\3\2\2\2\u011b\u0119\3\2\2\2\u011b"+
+    "\u011c\3\2\2\2\u011c\25\3\2\2\2\u011d\u011b\3\2\2\2\u011e\u011f\5\30\r"+
+    "\2\u011f\27\3\2\2\2\u0120\u0129\7\3\2\2\u0121\u0126\5*\26\2\u0122\u0123"+
+    "\7\5\2\2\u0123\u0125\5*\26\2\u0124\u0122\3\2\2\2\u0125\u0128\3\2\2\2\u0126"+
+    "\u0124\3\2\2\2\u0126\u0127\3\2\2\2\u0127\u012a\3\2\2\2\u0128\u0126\3\2"+
+    "\2\2\u0129\u0121\3\2\2\2\u0129\u012a\3\2\2\2\u012a\u012b\3\2\2\2\u012b"+
+    "\u012e\7\4\2\2\u012c\u012e\5*\26\2\u012d\u0120\3\2\2\2\u012d\u012c\3\2"+
+    "\2\2\u012e\31\3\2\2\2\u012f\u0130\5B\"\2\u0130\u0131\7\f\2\2\u0131\u0132"+
+    "\7\3\2\2\u0132\u0133\5\n\6\2\u0133\u0134\7\4\2\2\u0134\33\3\2\2\2\u0135"+
+    "\u0136\t\t\2\2\u0136\35\3\2\2\2\u0137\u013c\5*\26\2\u0138\u013a\7\f\2"+
+    "\2\u0139\u0138\3\2\2\2\u0139\u013a\3\2\2\2\u013a\u013b\3\2\2\2\u013b\u013d"+
+    "\5B\"\2\u013c\u0139\3\2\2\2\u013c\u013d\3\2\2\2\u013d\37\3\2\2\2\u013e"+
+    "\u0142\5(\25\2\u013f\u0141\5\"\22\2\u0140\u013f\3\2\2\2\u0141\u0144\3"+
+    "\2\2\2\u0142\u0140\3\2\2\2\u0142\u0143\3\2\2\2\u0143!\3\2\2\2\u0144\u0142"+
+    "\3\2\2\2\u0145\u0146\5$\23\2\u0146\u0147\7(\2\2\u0147\u0149\5(\25\2\u0148"+
+    "\u014a\5&\24\2\u0149\u0148\3\2\2\2\u0149\u014a\3\2\2\2\u014a\u0151\3\2"+
+    "\2\2\u014b\u014c\7.\2\2\u014c\u014d\5$\23\2\u014d\u014e\7(\2\2\u014e\u014f"+
+    "\5(\25\2\u014f\u0151\3\2\2\2\u0150\u0145\3\2\2\2\u0150\u014b\3\2\2\2\u0151"+
+    "#\3\2\2\2\u0152\u0154\7&\2\2\u0153\u0152\3\2\2\2\u0153\u0154\3\2\2\2\u0154"+
+    "\u0162\3\2\2\2\u0155\u0157\7)\2\2\u0156\u0158\7\65\2\2\u0157\u0156\3\2"+
+    "\2\2\u0157\u0158\3\2\2\2\u0158\u0162\3\2\2\2\u0159\u015b\79\2\2\u015a"+
+    "\u015c\7\65\2\2\u015b\u015a\3\2\2\2\u015b\u015c\3\2\2\2\u015c\u0162\3"+
+    "\2\2\2\u015d\u015f\7 \2\2\u015e\u0160\7\65\2\2\u015f\u015e\3\2\2\2\u015f"+
+    "\u0160\3\2\2\2\u0160\u0162\3\2\2\2\u0161\u0153\3\2\2\2\u0161\u0155\3\2"+
+    "\2\2\u0161\u0159\3\2\2\2\u0161\u015d\3\2\2\2\u0162%\3\2\2\2\u0163\u0164"+
+    "\7\61\2\2\u0164\u0172\5,\27\2\u0165\u0166\7F\2\2\u0166\u0167\7\3\2\2\u0167"+
+    "\u016c\5B\"\2\u0168\u0169\7\5\2\2\u0169\u016b\5B\"\2\u016a\u0168\3\2\2"+
+    "\2\u016b\u016e\3\2\2\2\u016c\u016a\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016f"+
+    "\3\2\2\2\u016e\u016c\3\2\2\2\u016f\u0170\7\4\2\2\u0170\u0172\3\2\2\2\u0171"+
+    "\u0163\3\2\2\2\u0171\u0165\3\2\2\2\u0172\'\3\2\2\2\u0173\u0178\5D#\2\u0174"+
+    "\u0176\7\f\2\2\u0175\u0174\3\2\2\2\u0175\u0176\3\2\2\2\u0176\u0177\3\2"+
+    "\2\2\u0177\u0179\5@!\2\u0178\u0175\3\2\2\2\u0178\u0179\3\2\2\2\u0179\u018d"+
+    "\3\2\2\2\u017a\u017b\7\3\2\2\u017b\u017c\5\n\6\2\u017c\u0181\7\4\2\2\u017d"+
+    "\u017f\7\f\2\2\u017e\u017d\3\2\2\2\u017e\u017f\3\2\2\2\u017f\u0180\3\2"+
+    "\2\2\u0180\u0182\5@!\2\u0181\u017e\3\2\2\2\u0181\u0182\3\2\2\2\u0182\u018d"+
+    "\3\2\2\2\u0183\u0184\7\3\2\2\u0184\u0185\5 \21\2\u0185\u018a\7\4\2\2\u0186"+
+    "\u0188\7\f\2\2\u0187\u0186\3\2\2\2\u0187\u0188\3\2\2\2\u0188\u0189\3\2"+
+    "\2\2\u0189\u018b\5@!\2\u018a\u0187\3\2\2\2\u018a\u018b\3\2\2\2\u018b\u018d"+
+    "\3\2\2\2\u018c\u0173\3\2\2\2\u018c\u017a\3\2\2\2\u018c\u0183\3\2\2\2\u018d"+
+    ")\3\2\2\2\u018e\u018f\5,\27\2\u018f+\3\2\2\2\u0190\u0191\b\27\1\2\u0191"+
+    "\u0192\7/\2\2\u0192\u01c2\5,\27\n\u0193\u0194\7\32\2\2\u0194\u0195\7\3"+
+    "\2\2\u0195\u0196\5\b\5\2\u0196\u0197\7\4\2\2\u0197\u01c2\3\2\2\2\u0198"+
+    "\u0199\7;\2\2\u0199\u019a\7\3\2\2\u019a\u019f\5L\'\2\u019b\u019c\7\5\2"+
+    "\2\u019c\u019e\5L\'\2\u019d\u019b\3\2\2\2\u019e\u01a1\3\2\2\2\u019f\u019d"+
+    "\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a2\3\2\2\2\u01a1\u019f\3\2\2\2\u01a2"+
+    "\u01a3\7\4\2\2\u01a3\u01c2\3\2\2\2\u01a4\u01a5\7-\2\2\u01a5\u01a6\7\3"+
+    "\2\2\u01a6\u01a7\5@!\2\u01a7\u01a8\7\5\2\2\u01a8\u01ad\5L\'\2\u01a9\u01aa"+
+    "\7\5\2\2\u01aa\u01ac\5L\'\2\u01ab\u01a9\3\2\2\2\u01ac\u01af\3\2\2\2\u01ad"+
+    "\u01ab\3\2\2\2\u01ad\u01ae\3\2\2\2\u01ae\u01b0\3\2\2\2\u01af\u01ad\3\2"+
+    "\2\2\u01b0\u01b1\7\4\2\2\u01b1\u01c2\3\2\2\2\u01b2\u01b3\7-\2\2\u01b3"+
+    "\u01b4\7\3\2\2\u01b4\u01b5\5L\'\2\u01b5\u01b6\7\5\2\2\u01b6\u01bb\5L\'"+
+    "\2\u01b7\u01b8\7\5\2\2\u01b8\u01ba\5L\'\2\u01b9\u01b7\3\2\2\2\u01ba\u01bd"+
+    "\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc\u01be\3\2\2\2\u01bd"+
+    "\u01bb\3\2\2\2\u01be\u01bf\7\4\2\2\u01bf\u01c2\3\2\2\2\u01c0\u01c2\5."+
+    "\30\2\u01c1\u0190\3\2\2\2\u01c1\u0193\3\2\2\2\u01c1\u0198\3\2\2\2\u01c1"+
+    "\u01a4\3\2\2\2\u01c1\u01b2\3\2\2\2\u01c1\u01c0\3\2\2\2\u01c2\u01cb\3\2"+
+    "\2\2\u01c3\u01c4\f\4\2\2\u01c4\u01c5\7\n\2\2\u01c5\u01ca\5,\27\5\u01c6"+
+    "\u01c7\f\3\2\2\u01c7\u01c8\7\63\2\2\u01c8\u01ca\5,\27\4\u01c9\u01c3\3"+
+    "\2\2\2\u01c9\u01c6\3\2\2\2\u01ca\u01cd\3\2\2\2\u01cb\u01c9\3\2\2\2\u01cb"+
+    "\u01cc\3\2\2\2\u01cc-\3\2\2\2\u01cd\u01cb\3\2\2\2\u01ce\u01d0\5\64\33"+
+    "\2\u01cf\u01d1\5\60\31\2\u01d0\u01cf\3\2\2\2\u01d0\u01d1\3\2\2\2\u01d1"+
+    "/\3\2\2\2\u01d2\u01d4\7/\2\2\u01d3\u01d2\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4"+
+    "\u01d5\3\2\2\2\u01d5\u01d6\7\16\2\2\u01d6\u01d7\5\64\33\2\u01d7\u01d8"+
+    "\7\n\2\2\u01d8\u01d9\5\64\33\2\u01d9\u0201\3\2\2\2\u01da\u01dc\7/\2\2"+
+    "\u01db\u01da\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd\u01de"+
+    "\7%\2\2\u01de\u01df\7\3\2\2\u01df\u01e4\5*\26\2\u01e0\u01e1\7\5\2\2\u01e1"+
+    "\u01e3\5*\26\2\u01e2\u01e0\3\2\2\2\u01e3\u01e6\3\2\2\2\u01e4\u01e2\3\2"+
+    "\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e7\3\2\2\2\u01e6\u01e4\3\2\2\2\u01e7"+
+    "\u01e8\7\4\2\2\u01e8\u0201\3\2\2\2\u01e9\u01eb\7/\2\2\u01ea\u01e9\3\2"+
+    "\2\2\u01ea\u01eb\3\2\2\2\u01eb\u01ec\3\2\2\2\u01ec\u01ed\7%\2\2\u01ed"+
+    "\u01ee\7\3\2\2\u01ee\u01ef\5\b\5\2\u01ef\u01f0\7\4\2\2\u01f0\u0201\3\2"+
+    "\2\2\u01f1\u01f3\7/\2\2\u01f2\u01f1\3\2\2\2\u01f2\u01f3\3\2\2\2\u01f3"+
+    "\u01f4\3\2\2\2\u01f4\u01f5\7*\2\2\u01f5\u0201\5\62\32\2\u01f6\u01f8\7"+
+    "/\2\2\u01f7\u01f6\3\2\2\2\u01f7\u01f8\3\2\2\2\u01f8\u01f9\3\2\2\2\u01f9"+
+    "\u01fa\7:\2\2\u01fa\u0201\5L\'\2\u01fb\u01fd\7\'\2\2\u01fc\u01fe\7/\2"+
+    "\2\u01fd\u01fc\3\2\2\2\u01fd\u01fe\3\2\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201"+
+    "\7\60\2\2\u0200\u01d3\3\2\2\2\u0200\u01db\3\2\2\2\u0200\u01ea\3\2\2\2"+
+    "\u0200\u01f2\3\2\2\2\u0200\u01f7\3\2\2\2\u0200\u01fb\3\2\2\2\u0201\61"+
+    "\3\2\2\2\u0202\u0205\5L\'\2\u0203\u0204\7\30\2\2\u0204\u0206\5L\'\2\u0205"+
+    "\u0203\3\2\2\2\u0205\u0206\3\2\2\2\u0206\63\3\2\2\2\u0207\u0208\b\33\1"+
+    "\2\u0208\u020c\5\66\34\2\u0209\u020a\t\n\2\2\u020a\u020c\5\64\33\6\u020b"+
+    "\u0207\3\2\2\2\u020b\u0209\3\2\2\2\u020c\u0219\3\2\2\2\u020d\u020e\f\5"+
+    "\2\2\u020e\u020f\t\13\2\2\u020f\u0218\5\64\33\6\u0210\u0211\f\4\2\2\u0211"+
+    "\u0212\t\n\2\2\u0212\u0218\5\64\33\5\u0213\u0214\f\3\2\2\u0214\u0215\5"+
+    ":\36\2\u0215\u0216\5\64\33\4\u0216\u0218\3\2\2\2\u0217\u020d\3\2\2\2\u0217"+
+    "\u0210\3\2\2\2\u0217\u0213\3\2\2\2\u0218\u021b\3\2\2\2\u0219\u0217\3\2"+
+    "\2\2\u0219\u021a\3\2\2\2\u021a\65\3\2\2\2\u021b\u0219\3\2\2\2\u021c\u021d"+
+    "\7\20\2\2\u021d\u021e\7\3\2\2\u021e\u021f\5*\26\2\u021f\u0220\7\f\2\2"+
+    "\u0220\u0221\5> \2\u0221\u0222\7\4\2\2\u0222\u024e\3\2\2\2\u0223\u0224"+
+    "\7\34\2\2\u0224\u0225\7\3\2\2\u0225\u0226\5B\"\2\u0226\u0227\7\37\2\2"+
+    "\u0227\u0228\5\64\33\2\u0228\u0229\7\4\2\2\u0229\u024e\3\2\2\2\u022a\u024e"+
+    "\58\35\2\u022b\u024e\7R\2\2\u022c\u022d\5@!\2\u022d\u022e\7V\2\2\u022e"+
+    "\u0230\3\2\2\2\u022f\u022c\3\2\2\2\u022f\u0230\3\2\2\2\u0230\u0231\3\2"+
+    "\2\2\u0231\u024e\7R\2\2\u0232\u0233\5B\"\2\u0233\u023f\7\3\2\2\u0234\u0236"+
+    "\5\34\17\2\u0235\u0234\3\2\2\2\u0235\u0236\3\2\2\2\u0236\u0237\3\2\2\2"+
+    "\u0237\u023c\5*\26\2\u0238\u0239\7\5\2\2\u0239\u023b\5*\26\2\u023a\u0238"+
+    "\3\2\2\2\u023b\u023e\3\2\2\2\u023c\u023a\3\2\2\2\u023c\u023d\3\2\2\2\u023d"+
+    "\u0240\3\2\2\2\u023e\u023c\3\2\2\2\u023f\u0235\3\2\2\2\u023f\u0240\3\2"+
+    "\2\2\u0240\u0241\3\2\2\2\u0241\u0242\7\4\2\2\u0242\u024e\3\2\2\2\u0243"+
+    "\u0244\7\3\2\2\u0244\u0245\5\b\5\2\u0245\u0246\7\4\2\2\u0246\u024e\3\2"+
+    "\2\2\u0247\u024e\5B\"\2\u0248\u024e\5@!\2\u0249\u024a\7\3\2\2\u024a\u024b"+
+    "\5*\26\2\u024b\u024c\7\4\2\2\u024c\u024e\3\2\2\2\u024d\u021c\3\2\2\2\u024d"+
+    "\u0223\3\2\2\2\u024d\u022a\3\2\2\2\u024d\u022b\3\2\2\2\u024d\u022f\3\2"+
+    "\2\2\u024d\u0232\3\2\2\2\u024d\u0243\3\2\2\2\u024d\u0247\3\2\2\2\u024d"+
+    "\u0248\3\2\2\2\u024d\u0249\3\2\2\2\u024e\67\3\2\2\2\u024f\u0259\7\60\2"+
+    "\2\u0250\u0259\5J&\2\u0251\u0259\5<\37\2\u0252\u0254\7X\2\2\u0253\u0252"+
+    "\3\2\2\2\u0254\u0255\3\2\2\2\u0255\u0253\3\2\2\2\u0255\u0256\3\2\2\2\u0256"+
+    "\u0259\3\2\2\2\u0257\u0259\7W\2\2\u0258\u024f\3\2\2\2\u0258\u0250\3\2"+
+    "\2\2\u0258\u0251\3\2\2\2\u0258\u0253\3\2\2\2\u0258\u0257\3\2\2\2\u0259"+
+    "9\3\2\2\2\u025a\u025b\t\f\2\2\u025b;\3\2\2\2\u025c\u025d\t\r\2\2\u025d"+
+    "=\3\2\2\2\u025e\u025f\5B\"\2\u025f?\3\2\2\2\u0260\u0261\5B\"\2\u0261\u0262"+
+    "\7V\2\2\u0262\u0264\3\2\2\2\u0263\u0260\3\2\2\2\u0264\u0267\3\2\2\2\u0265"+
+    "\u0263\3\2\2\2\u0265\u0266\3\2\2\2\u0266\u0268\3\2\2\2\u0267\u0265\3\2"+
+    "\2\2\u0268\u0269\5B\"\2\u0269A\3\2\2\2\u026a\u026d\5F$\2\u026b\u026d\5"+
+    "H%\2\u026c\u026a\3\2\2\2\u026c\u026b\3\2\2\2\u026dC\3\2\2\2\u026e\u026f"+
+    "\5B\"\2\u026f\u0270\7\6\2\2\u0270\u0272\3\2\2\2\u0271\u026e\3\2\2\2\u0271"+
+    "\u0272\3\2\2\2\u0272\u0273\3\2\2\2\u0273\u027b\7]\2\2\u0274\u0275\5B\""+
+    "\2\u0275\u0276\7\6\2\2\u0276\u0278\3\2\2\2\u0277\u0274\3\2\2\2\u0277\u0278"+
+    "\3\2\2\2\u0278\u0279\3\2\2\2\u0279\u027b\5B\"\2\u027a\u0271\3\2\2\2\u027a"+
+    "\u0277\3\2\2\2\u027bE\3\2\2\2\u027c\u027f\7^\2\2\u027d\u027f\7_\2\2\u027e"+
+    "\u027c\3\2\2\2\u027e\u027d\3\2\2\2\u027fG\3\2\2\2\u0280\u0284\7[\2\2\u0281"+
+    "\u0284\5N(\2\u0282\u0284\7\\\2\2\u0283\u0280\3\2\2\2\u0283\u0281\3\2\2"+
+    "\2\u0283\u0282\3\2\2\2\u0284I\3\2\2\2\u0285\u0288\7Z\2\2\u0286\u0288\7"+
+    "Y\2\2\u0287\u0285\3\2\2\2\u0287\u0286\3\2\2\2\u0288K\3\2\2\2\u0289\u028a"+
+    "\t\16\2\2\u028aM\3\2\2\2\u028b\u028c\t\17\2\2\u028cO\3\2\2\2`_aenptz}"+
+    "\u0088\u008b\u0095\u0098\u009b\u009e\u00a6\u00a9\u00af\u00b3\u00b6\u00b9"+
+    "\u00bc\u00c3\u00cb\u00ce\u00da\u00dd\u00e1\u00e8\u00ec\u00f0\u00f7\u00fb"+
+    "\u00ff\u0104\u0108\u0110\u0114\u011b\u0126\u0129\u012d\u0139\u013c\u0142"+
+    "\u0149\u0150\u0153\u0157\u015b\u015f\u0161\u016c\u0171\u0175\u0178\u017e"+
+    "\u0181\u0187\u018a\u018c\u019f\u01ad\u01bb\u01c1\u01c9\u01cb\u01d0\u01d3"+
+    "\u01db\u01e4\u01ea\u01f2\u01f7\u01fd\u0200\u0205\u020b\u0217\u0219\u022f"+
+    "\u0235\u023c\u023f\u024d\u0255\u0258\u0265\u026c\u0271\u0277\u027a\u027e"+
+    "\u0283\u0287";
   public static final ATN _ATN =
     new ATNDeserializer().deserialize(_serializedATN.toCharArray());
   static {
diff --git a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseVisitor.java b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseVisitor.java
index 0380373dfd5..35ce6cd0029 100644
--- a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseVisitor.java
+++ b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlBaseVisitor.java
@@ -431,12 +431,12 @@ interface SqlBaseVisitor<T> extends ParseTreeVisitor<T> {
    */
   T visitStringLiteral(SqlBaseParser.StringLiteralContext ctx);
   /**
-   * Visit a parse tree produced by the {@code param}
+   * Visit a parse tree produced by the {@code paramLiteral}
    * labeled alternative in {@link SqlBaseParser#constant}.
    * @param ctx the parse tree
    * @return the visitor result
    */
-  T visitParam(SqlBaseParser.ParamContext ctx);
+  T visitParamLiteral(SqlBaseParser.ParamLiteralContext ctx);
   /**
    * Visit a parse tree produced by {@link SqlBaseParser#comparisonOperator}.
    * @param ctx the parse tree
@@ -516,6 +516,12 @@ interface SqlBaseVisitor<T> extends ParseTreeVisitor<T> {
    * @return the visitor result
    */
   T visitIntegerLiteral(SqlBaseParser.IntegerLiteralContext ctx);
+  /**
+   * Visit a parse tree produced by {@link SqlBaseParser#string}.
+   * @param ctx the parse tree
+   * @return the visitor result
+   */
+  T visitString(SqlBaseParser.StringContext ctx);
   /**
    * Visit a parse tree produced by {@link SqlBaseParser#nonReserved}.
    * @param ctx the parse tree
diff --git a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlParser.java b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlParser.java
index 12b1d2604fc..7aa3748e31e 100644
--- a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlParser.java
+++ b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/parser/SqlParser.java
@@ -40,10 +40,6 @@ import java.util.function.Function;
 public class SqlParser {
     private static final Logger log = Loggers.getLogger(SqlParser.class);
 
-    /**
-     * Time zone in which the SQL is parsed. This is attached to functions
-     * that deal with dates and times.
-     */
     private final boolean DEBUG = false;
 
     /**
@@ -119,7 +115,7 @@ public class SqlParser {
 
         parser.addParseListener(parser.new TraceListener());
 
-        parser.addErrorListener(new DiagnosticErrorListener() {
+        parser.addErrorListener(new DiagnosticErrorListener(false) {
             @Override
             public void reportAttemptingFullContext(Parser recognizer, DFA dfa,
                     int startIndex, int stopIndex, BitSet conflictingAlts, ATNConfigSet configs) {}
diff --git a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/type/DataTypes.java b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/type/DataTypes.java
index bece82ec81b..c2b40656ba2 100644
--- a/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/type/DataTypes.java
+++ b/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/type/DataTypes.java
@@ -46,7 +46,7 @@ public abstract class DataTypes {
         if (value instanceof DateTime) {
             return DataType.DATE;
         }
-        if (value instanceof String) {
+        if (value instanceof String || value instanceof Character) {
             return DataType.KEYWORD;
         }
         throw new SqlIllegalArgumentException("No idea what's the DataType for {}", value.getClass());
diff --git a/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/parser/LikeEscapingParsingTests.java b/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/parser/LikeEscapingParsingTests.java
index b0b19aaa94c..c94bcf0e664 100644
--- a/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/parser/LikeEscapingParsingTests.java
+++ b/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/parser/LikeEscapingParsingTests.java
@@ -9,9 +9,12 @@ import org.elasticsearch.test.ESTestCase;
 import org.elasticsearch.xpack.sql.expression.Expression;
 import org.elasticsearch.xpack.sql.expression.regex.Like;
 import org.elasticsearch.xpack.sql.expression.regex.LikePattern;
+import org.elasticsearch.xpack.sql.plugin.SqlTypedParamValue;
+import org.elasticsearch.xpack.sql.type.DataType;
 
 import java.util.Locale;
 
+import static java.util.Collections.singletonList;
 import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.Matchers.is;
 
@@ -27,14 +30,20 @@ public class LikeEscapingParsingTests extends ESTestCase {
     }
 
     private LikePattern like(String pattern) {
-        Expression exp = parser.createExpression(String.format(Locale.ROOT, "exp LIKE %s", pattern));
+        Expression exp = null;
+        boolean parameterized = randomBoolean();
+        if (parameterized) {
+            exp = parser.createExpression("exp LIKE ?", singletonList(new SqlTypedParamValue(pattern, DataType.KEYWORD)));
+        } else {
+            exp = parser.createExpression(String.format(Locale.ROOT, "exp LIKE '%s'", pattern));
+        }
         assertThat(exp, instanceOf(Like.class));
         Like l = (Like) exp;
         return l.right();
     }
 
     public void testNoEscaping() {
-        LikePattern like = like("'string'");
+        LikePattern like = like("string");
         assertThat(like.pattern(), is("string"));
         assertThat(like.asJavaRegex(), is("^string$"));
         assertThat(like.asLuceneWildcard(), is("string"));
diff --git a/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysCatalogTests.java b/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysCatalogsTests.java
similarity index 72%
rename from plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysCatalogTests.java
rename to plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysCatalogsTests.java
index 8748e85815b..438644ca03f 100644
--- a/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysCatalogTests.java
+++ b/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysCatalogsTests.java
@@ -19,30 +19,40 @@ import org.elasticsearch.xpack.sql.session.SqlSession;
 import org.elasticsearch.xpack.sql.type.TypesTests;
 import org.joda.time.DateTimeZone;
 
+import static java.util.Collections.singletonList;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
-public class SysCatalogTests extends ESTestCase {
+public class SysCatalogsTests extends ESTestCase {
 
     private final SqlParser parser = new SqlParser();
 
+    @SuppressWarnings({ "rawtypes", "unchecked" })
     private Tuple<Command, SqlSession> sql(String sql) {
         EsIndex test = new EsIndex("test", TypesTests.loadMapping("mapping-multi-field-with-nested.json", true));
         Analyzer analyzer = new Analyzer(new FunctionRegistry(), IndexResolution.valid(test), DateTimeZone.UTC);
         Command cmd = (Command) analyzer.analyze(parser.createStatement(sql), true);
 
         IndexResolver resolver = mock(IndexResolver.class);
+        when(resolver.clusterName()).thenReturn("cluster");
+
+        doAnswer(invocation -> {
+            ((ActionListener) invocation.getArguments()[2]).onResponse(singletonList(test));
+            return Void.TYPE;
+        }).when(resolver).resolveAsSeparateMappings(any(), any(), any());
+
         SqlSession session = new SqlSession(null, null, null, resolver, null, null, null);
         return new Tuple<>(cmd, session);
     }
 
     public void testSysCatalogs() throws Exception {
-        Tuple<Command, SqlSession> sql = sql("SYS TABLE TYPES");
+        Tuple<Command, SqlSession> sql = sql("SYS CATALOGS");
 
         sql.v1().execute(sql.v2(), ActionListener.wrap(r -> {
-            assertEquals(2, r.size());
-            assertEquals("BASE TABLE", r.column(0));
-            r.advanceRow();
-            assertEquals("ALIAS", r.column(0));
+            assertEquals(1, r.size());
+            assertEquals("cluster", r.column(0));
         }, ex -> fail(ex.getMessage())));
     }
 }
\ No newline at end of file
diff --git a/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysTableTypesTests.java b/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysTableTypesTests.java
index 2703e440803..55319dae0a2 100644
--- a/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysTableTypesTests.java
+++ b/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysTableTypesTests.java
@@ -19,40 +19,30 @@ import org.elasticsearch.xpack.sql.session.SqlSession;
 import org.elasticsearch.xpack.sql.type.TypesTests;
 import org.joda.time.DateTimeZone;
 
-import static java.util.Collections.singletonList;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
 
 public class SysTableTypesTests extends ESTestCase {
 
     private final SqlParser parser = new SqlParser();
 
-    @SuppressWarnings({ "rawtypes", "unchecked" })
     private Tuple<Command, SqlSession> sql(String sql) {
         EsIndex test = new EsIndex("test", TypesTests.loadMapping("mapping-multi-field-with-nested.json", true));
         Analyzer analyzer = new Analyzer(new FunctionRegistry(), IndexResolution.valid(test), DateTimeZone.UTC);
         Command cmd = (Command) analyzer.analyze(parser.createStatement(sql), true);
 
         IndexResolver resolver = mock(IndexResolver.class);
-        when(resolver.clusterName()).thenReturn("cluster");
-
-        doAnswer(invocation -> {
-            ((ActionListener) invocation.getArguments()[2]).onResponse(singletonList(test));
-            return Void.TYPE;
-        }).when(resolver).resolveAsSeparateMappings(any(), any(), any());
-
         SqlSession session = new SqlSession(null, null, null, resolver, null, null, null);
         return new Tuple<>(cmd, session);
     }
 
     public void testSysCatalogs() throws Exception {
-        Tuple<Command, SqlSession> sql = sql("SYS CATALOGS");
+        Tuple<Command, SqlSession> sql = sql("SYS TABLE TYPES");
 
         sql.v1().execute(sql.v2(), ActionListener.wrap(r -> {
-            assertEquals(1, r.size());
-            assertEquals("cluster", r.column(0));
+            assertEquals(2, r.size());
+            assertEquals("BASE TABLE", r.column(0));
+            r.advanceRow();
+            assertEquals("ALIAS", r.column(0));
         }, ex -> fail(ex.getMessage())));
     }
 }
\ No newline at end of file
diff --git a/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysTablesTests.java b/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysTablesTests.java
index ac53cdc8b60..a1b96373748 100644
--- a/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysTablesTests.java
+++ b/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/plan/logical/command/sys/SysTablesTests.java
@@ -18,17 +18,21 @@ import org.elasticsearch.xpack.sql.expression.function.FunctionRegistry;
 import org.elasticsearch.xpack.sql.parser.ParsingException;
 import org.elasticsearch.xpack.sql.parser.SqlParser;
 import org.elasticsearch.xpack.sql.plan.logical.command.Command;
+import org.elasticsearch.xpack.sql.plugin.SqlTypedParamValue;
 import org.elasticsearch.xpack.sql.session.SchemaRowSet;
 import org.elasticsearch.xpack.sql.session.SqlSession;
+import org.elasticsearch.xpack.sql.type.DataTypes;
 import org.elasticsearch.xpack.sql.type.EsField;
 import org.elasticsearch.xpack.sql.type.TypesTests;
 import org.joda.time.DateTimeZone;
 
 import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;
 
 import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
 import static org.elasticsearch.action.ActionListener.wrap;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.doAnswer;
@@ -67,6 +71,16 @@ public class SysTablesTests extends ESTestCase {
         }, index, alias);
     }
 
+    public void testSysTablesPatternParameterized() throws Exception {
+        List<SqlTypedParamValue> params = asList(param("%"));
+        executeCommand("SYS TABLES LIKE ?", params, r -> {
+            assertEquals(2, r.size());
+            assertEquals("test", r.column(2));
+            assertTrue(r.advanceRow());
+            assertEquals("alias", r.column(2));
+        }, index, alias);
+    }
+
     public void testSysTablesOnlyAliases() throws Exception {
         executeCommand("SYS TABLES LIKE 'test' TYPE 'ALIAS'", r -> {
             assertEquals(1, r.size());
@@ -74,6 +88,14 @@ public class SysTablesTests extends ESTestCase {
         }, alias);
     }
 
+    public void testSysTablesOnlyAliasesParameterized() throws Exception {
+        List<SqlTypedParamValue> params = asList(param("ALIAS"));
+        executeCommand("SYS TABLES LIKE 'test' TYPE ?", params, r -> {
+            assertEquals(1, r.size());
+            assertEquals("alias", r.column(2));
+        }, alias);
+    }
+
     public void testSysTablesOnlyIndices() throws Exception {
         executeCommand("SYS TABLES LIKE 'test' TYPE 'BASE TABLE'", r -> {
             assertEquals(1, r.size());
@@ -81,6 +103,13 @@ public class SysTablesTests extends ESTestCase {
         }, index);
     }
 
+    public void testSysTablesOnlyIndicesParameterized() throws Exception {
+        executeCommand("SYS TABLES LIKE 'test' TYPE ?", asList(param("ALIAS")), r -> {
+            assertEquals(1, r.size());
+            assertEquals("test", r.column(2));
+        }, index);
+    }
+
     public void testSysTablesOnlyIndicesAndAliases() throws Exception {
         executeCommand("SYS TABLES LIKE 'test' TYPE 'ALIAS', 'BASE TABLE'", r -> {
             assertEquals(2, r.size());
@@ -90,15 +119,33 @@ public class SysTablesTests extends ESTestCase {
         }, index, alias);
     }
 
+    public void testSysTablesOnlyIndicesAndAliasesParameterized() throws Exception {
+        List<SqlTypedParamValue> params = asList(param("ALIAS"), param("BASE TABLE"));
+        executeCommand("SYS TABLES LIKE 'test' TYPE ?, ?", params, r -> {
+            assertEquals(2, r.size());
+            assertEquals("test", r.column(2));
+            assertTrue(r.advanceRow());
+            assertEquals("alias", r.column(2));
+        }, index, alias);
+    }
+
     public void testSysTablesWithInvalidType() throws Exception {
         ParsingException pe = expectThrows(ParsingException.class, () -> sql("SYS TABLES LIKE 'test' TYPE 'QUE HORA ES'"));
         assertEquals("line 1:2: Invalid table type [QUE HORA ES]", pe.getMessage());
     }
 
+    private SqlTypedParamValue param(Object value) {
+        return new SqlTypedParamValue(value, DataTypes.fromJava(value));
+    }
+
     private Tuple<Command, SqlSession> sql(String sql) {
+        return sql(sql, emptyList());
+    }
+
+    private Tuple<Command, SqlSession> sql(String sql, List<SqlTypedParamValue> params) {
         EsIndex test = new EsIndex("test", mapping);
         Analyzer analyzer = new Analyzer(new FunctionRegistry(), IndexResolution.valid(test), DateTimeZone.UTC);
-        Command cmd = (Command) analyzer.analyze(parser.createStatement(sql), true);
+        Command cmd = (Command) analyzer.analyze(parser.createStatement(sql, params), true);
 
         IndexResolver resolver = mock(IndexResolver.class);
         when(resolver.clusterName()).thenReturn("cluster");
@@ -107,9 +154,14 @@ public class SysTablesTests extends ESTestCase {
         return new Tuple<>(cmd, session);
     }
 
-    @SuppressWarnings({ "unchecked", "rawtypes" })
     private void executeCommand(String sql, Consumer<SchemaRowSet> consumer, IndexInfo... infos) throws Exception {
-        Tuple<Command, SqlSession> tuple = sql(sql);
+        executeCommand(sql, emptyList(), consumer, infos);
+    }
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    private void executeCommand(String sql, List<SqlTypedParamValue> params, Consumer<SchemaRowSet> consumer, IndexInfo... infos)
+            throws Exception {
+        Tuple<Command, SqlSession> tuple = sql(sql, params);
 
         IndexResolver resolver = tuple.v2().indexResolver();
 
diff --git a/qa/sql/src/main/java/org/elasticsearch/xpack/qa/sql/jdbc/DatabaseMetaDataTestCase.java b/qa/sql/src/main/java/org/elasticsearch/xpack/qa/sql/jdbc/DatabaseMetaDataTestCase.java
index 8aeaa05a99a..86dc4f5a9a8 100644
--- a/qa/sql/src/main/java/org/elasticsearch/xpack/qa/sql/jdbc/DatabaseMetaDataTestCase.java
+++ b/qa/sql/src/main/java/org/elasticsearch/xpack/qa/sql/jdbc/DatabaseMetaDataTestCase.java
@@ -87,4 +87,4 @@ public class DatabaseMetaDataTestCase extends JdbcIntegrationTestCase {
             assertResultSets(expected, es.getMetaData().getColumns(null, "%", "%", null));
         }
     }
-}
+}
\ No newline at end of file
diff --git a/qa/sql/src/main/resources/setup_mock_metadata_get_table_type.sql b/qa/sql/src/main/resources/setup_mock_metadata_get_table_type.sql
new file mode 100644
index 00000000000..db40c6b9086
--- /dev/null
+++ b/qa/sql/src/main/resources/setup_mock_metadata_get_table_type.sql
@@ -0,0 +1,15 @@
+CREATE TABLE mock (
+  TABLE_SCHEM VARCHAR,
+  TABLE_NAME VARCHAR,
+  TABLE_TYPE VARCHAR,
+  REMARKS VARCHAR,
+  TYPE_CAT VARCHAR,
+  TYPE_SCHEM VARCHAR,
+  TYPE_NAME VARCHAR,
+  SELF_REFERENCING_COL_NAME VARCHAR,
+  REF_GENERATION VARCHAR
+) AS
+SELECT '', 'test1', 'BASE TABLE', '', null, null, null, null, null FROM DUAL
+UNION ALL
+SELECT '', 'test2', 'BASE TABLE', '', null, null, null, null, null FROM DUAL
+;