Pārlūkot izejas kodu

HUE-7279 [autocomplete] Mark column alias locations

Johan Ahlen 8 gadi atpakaļ
vecāks
revīzija
bbe6a88

+ 25 - 16
desktop/core/src/desktop/static/desktop/js/autocomplete/jison/sql_main.jison

@@ -2588,11 +2588,12 @@ SelectSpecification
  : ValueExpression OptionalCorrelationName
    {
      if ($2) {
-       $$ = { valueExpression: $1, alias: $2 };
+       parser.addColumnAliasLocation($2.location, $2.alias, @1);
+       $$ = { valueExpression: $1, alias: $2.alias };
        if (!parser.yy.selectListAliases) {
          parser.yy.selectListAliases = [];
        }
-       parser.yy.selectListAliases.push({ name: $2, types: $1.types || ['T'] });
+       parser.yy.selectListAliases.push({ name: $2.alias, types: $1.types || ['T'] });
      } else {
        $$ = { valueExpression: $1 }
      }
@@ -2606,10 +2607,17 @@ SelectSpecification
 
 SelectSpecification_EDIT
  : ValueExpression_EDIT OptionalCorrelationName
+   {
+     if ($2) {
+       parser.addColumnAliasLocation($2.location, $2.alias, @1);
+     }
+   }
+
  | AnyCursor AnyAs RegularOrBacktickedIdentifier
    {
      parser.suggestFunctions();
      parser.suggestColumns();
+     parser.addColumnAliasLocation(@3, $3, @1);
      $$ = { suggestAggregateFunctions: true };
    }
  | ValueExpression OptionalCorrelationName_EDIT  -> $2
@@ -2898,8 +2906,8 @@ TablePrimary
    {
      if ($1.identifierChain) {
        if ($3) {
-         $1.alias = $3
-         parser.addTableAliasLocation(@3, $3, $1.identifierChain);
+         $1.alias = $3.alias
+         parser.addTableAliasLocation($3.location, $3.alias, $1.identifierChain);
        }
        parser.addTablePrimary($1);
      }
@@ -2909,9 +2917,9 @@ TablePrimary
  | DerivedTable OptionalCorrelationName
    {
      if ($2) {
-       $1.alias = $2;
-       parser.addTablePrimary({ subQueryAlias: $2 });
-       parser.addSubqueryAliasLocation(@2, $2, $1.identifierChain);
+       $1.alias = $2.alias;
+       parser.addTablePrimary({ subQueryAlias: $2.alias });
+       parser.addSubqueryAliasLocation($2.location, $2.alias, $1.identifierChain);
      } else {
        $$.suggestKeywords = [{ value: 'AS', weight: 1 }];
      }
@@ -2922,22 +2930,22 @@ TablePrimary_EDIT
  : TableOrQueryName_EDIT OptionalTableSample OptionalCorrelationName
    {
      if ($3) {
-       parser.addTableAliasLocation(@3, $3, $1.identifierChain);
+       parser.addTableAliasLocation($3.location, $3.alias, $1.identifierChain);
      }
    }
  | TableOrQueryName OptionalTableSample_EDIT OptionalCorrelationName
    {
      if ($3) {
-       $1.alias = $3;
-       parser.addTableAliasLocation(@3, $3, $1.identifierChain);
+       $1.alias = $3.alias;
+       parser.addTableAliasLocation($3.location, $3.alias, $1.identifierChain);
      }
      parser.addTablePrimary($1);
    }
  | DerivedTable_EDIT OptionalCorrelationName
    {
      if ($2) {
-       parser.addTablePrimary({ subQueryAlias: $2 });
-       parser.addSubqueryAliasLocation(@2, $2);
+       parser.addTablePrimary({ subQueryAlias: $2.alias });
+       parser.addSubqueryAliasLocation($2.location, $2.alias);
      }
    }
  | DerivedTable OptionalCorrelationName_EDIT
@@ -3018,8 +3026,9 @@ TableSubQuery
  | '(' DerivedTable OptionalCorrelationName ')'
    {
      if ($3) {
-       $2.alias = $3;
-       parser.addTablePrimary({ subQueryAlias: $3 });
+       $2.alias = $3.alias;
+       parser.addTablePrimary({ subQueryAlias: $3.alias });
+       parser.addSubqueryAliasLocation($3.location, $3.alias, $2.identifierChain);
      }
      $$ = $2;
    }
@@ -3108,8 +3117,8 @@ SimpleTable_EDIT
 
 OptionalCorrelationName
  :
- | RegularOrBacktickedIdentifier
- | AnyAs RegularOrBacktickedIdentifier  -> $2
+ | RegularOrBacktickedIdentifier        -> { alias: $1, location: @1 }
+ | AnyAs RegularOrBacktickedIdentifier  -> { alias: $2, location: @2 }
  ;
 
 OptionalCorrelationName_EDIT

+ 0 - 3043
desktop/core/src/desktop/static/desktop/js/autocomplete/jison/sql_valueExpression_dev.jison

@@ -1,3043 +0,0 @@
-// Licensed to Cloudera, Inc. under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  Cloudera, Inc. licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-%left 'AND' 'OR'
-%left 'BETWEEN'
-%left 'NOT' '!' '~'
-%left '=' '<' '>' 'COMPARISON_OPERATOR'
-%left '-' '*' 'ARITHMETIC_OPERATOR'
-
-%left ';' ','
-%nonassoc 'CURSOR' 'PARTIAL_CURSOR'
-%nonassoc 'IN' 'IS' '<impala>ILIKE' '<impala>IREGEXP' 'LIKE' 'RLIKE' 'REGEXP' 'EXISTS' NEGATION
-
-%start Sql
-
-%%
-
-NonReservedKeyword
- : '<hive>ADD'
- | '<hive>AFTER'
- | '<hive>ANALYZE'
- | '<hive>ARCHIVE'
- | '<hive>AVRO'
- | '<hive>BUCKET'
- | '<hive>BUCKETS'
- | '<hive>CACHE'
- | '<hive>CASCADE'
- | '<hive>CHANGE'
- | '<hive>CLUSTERED'
- | '<hive>COLLECTION'
- | '<hive>COLUMNS'
- | '<hive>COMMENT'
- | '<hive>COMPACT'
- | '<hive>COMPACTIONS'
- | '<hive>COMPUTE'
- | '<hive>CONCATENATE'
- | '<hive>DATA'
- | '<hive>DATABASES'
- | '<hive>DEFERRED'
- | '<hive>DEFINED'
- | '<hive>DELIMITED'
- | '<hive>DEPENDENCY'
- | '<hive>DIRECTORY'
- | '<hive>DISABLE'
- | '<hive>ENABLE'
- | '<hive>ESCAPED'
- | '<hive>EXCHANGE'
- | '<hive>EXPLAIN'
- | '<hive>FIELDS'
- | '<hive>FILE'
- | '<hive>FILEFORMAT'
- | '<hive>FIRST'
- | '<hive>FORMAT'
- | '<hive>FUNCTIONS'
- | '<hive>INPATH'
- | '<hive>INPUTFORMAT'
- | '<hive>JAR'
- | '<hive>IDXPROPERTIES'
- | '<hive>ITEMS'
- | '<hive>KEYS'
- | '<hive>LINES'
- | '<hive>LOAD'
- | '<hive>LOCATION'
- | '<hive>LOCKS'
- | '<hive>METADATA'
- | '<hive>MSCK'
- | '<hive>NOSCAN'
- | '<hive>NO_DROP'
- | '<hive>OFFLINE'
- | '<hive>ORC'
- | '<hive>OUTPUTFORMAT'
- | '<hive>OVERWRITE'
- | '<hive>PARQUET'
- | '<hive>PARTITIONED'
- | '<hive>PARTITIONS'
- | '<hive>PURGE'
- | '<hive>RCFILE'
- | '<hive>REBUILD'
- | '<hive>RELOAD'
- | '<hive>REPAIR'
- | '<hive>RECOVER'
- | '<hive>RENAME'
- | '<hive>REPLACE'
- | '<hive>RESTRICT'
- | '<hive>ROLE'
- | '<hive>ROLES'
- | '<hive>SCHEMAS'
- | '<hive>SEQUENCEFILE'
- | '<hive>SERDE'
- | '<hive>SERDEPROPERTIES'
- | '<hive>SETS'
- | '<hive>SHOW'
- | '<hive>SKEWED'
- | '<hive>SORTED'
- | '<hive>STATISTICS'
- | '<hive>STORED'
- | '<hive>STRING'
- | 'STRUCT'
- | '<hive>TABLES'
- | '<hive>TBLPROPERTIES'
- | '<hive>TEMPORARY'
- | '<hive>TERMINATED'
- | '<hive>TEXTFILE'
- | '<hive>TINYINT'
- | '<hive>TOUCH'
- | '<hive>TRANSACTIONS'
- | '<hive>UNARCHIVE'
- | '<hive>UNIONTYPE'
- | '<hive>USE'
- | '<hive>VIEW'
-// | '<hive>ASC'      // These cause conflicts, we could use a separate lexer state for DESCRIBE, ALTER and SHOW
-// | '<hive>CLUSTER'
-// | '<hive>DESC'
-// | '<hive>DISTRIBUTE'
-// | '<hive>FORMATTED'
-// | '<hive>FUNCTION'
-// | '<hive>INDEX'
-// | '<hive>INDEXES'
-// | '<hive>SCHEMA'
-// | '<hive>SORT'
- ;
-
-NonReservedKeyword
- : '<impala>ANALYTIC'
- | '<impala>ANTI'
- | '<impala>CURRENT'
- | '<impala>GRANT'
- | '<impala>ROLE'
- | '<impala>ROLES'
-// | '<impala>BROADCAST'
-// | '<impala>NOSHUFFLE'
-// | '<impala>SHUFFLE'
- ;
-
-NonReservedKeyword
- : 'ROLE'
- ;
-
-RegularIdentifier
- : 'REGULAR_IDENTIFIER'
- | 'VARIABLE_REFERENCE'
- | NonReservedKeyword
- ;
-
-NewStatement
- : /* empty */
-   {
-     parser.prepareNewStatement();
-   }
- ;
-
-Sql
- : QuerySpecification
- | QuerySpecification_EDIT
- ;
-
-
-SetSpecification
- : 'SET' SetOption '=' SetValue
- ;
-
-SetOption
- : RegularIdentifier
- | SetOption AnyDot RegularIdentifier
- ;
-
-SetValue
- : RegularIdentifier
- | SignedInteger
- | SignedInteger RegularIdentifier
- | QuotedValue
- | 'TRUE'
- | 'FALSE'
- | 'NULL'
- ;
-
-// This is a work-around for error handling when a statement starts with some token that the parser can understand but
-// it's not a valid statement (see ErrorStatement). It contains everything except valid starting tokens ('SELECT', 'USE' etc.)
-NonStartingToken
- : '<hive>ALL' | '<hive>AS' | '<hive>AUTHORIZATION' | '<hive>AVRO' | '<hive>BINARY' | '<hive>BUCKET' | '<hive>BUCKETS' | '<hive>CACHE' | '<hive>CLUSTER' | '<hive>CLUSTERED' | '<hive>COLLECTION' | '<hive>COMPUTE' | '<hive>CONF' | '<hive>CUBE' | '<hive>CURRENT' | '<hive>DATE' | '<hive>DEFERRED' | '<hive>DELIMITED' | '<hive>DEPENDENCY' | '<hive>DIRECTORY' | '<hive>DISTRIBUTE' | '<hive>DISTRIBUTED' | '<hive>ESCAPED' | '<hive>EXTENDED' | '<hive>EXTERNAL' | '<hive>FIELDS' | '<hive>FILE' | '<hive>FOR' | '<hive>FORMAT' | '<hive>FUNCTION' | '<hive>GRANT' | '<hive>GROUPING' | '<hive>IDXPROPERTIES' | '<hive>LATERAL' | '<hive>LOCAL' | '<hive>MACRO' | '<hive>OVERWRITE' | '<hive>PARTITION' | '<hive>REBUILD' | '<hive>REPAIR' | '<hive>ROLLUP' | '<hive>SETS' | '<hive>STATISTICS' | '<hive>TABLE' | '<hive>USER' | '<hive>ASC' | '<hive>COLUMNS' | '<hive>COMMENT' | '<hive>COMPACTIONS' | '<hive>DATA' | '<hive>DATABASES' | '<hive>DEFINED' | '<hive>DESC' |  '<hive>FORMATTED' | '<hive>FUNCTIONS' | '<hive>INDEX' | '<hive>INDEXES' | '<hive>INPATH' | '<hive>INPUTFORMAT' | '<hive>ITEMS' | '<hive>JAR' | '<hive>KEYS' | '<hive>LINES' | '<hive>LOCATION' | '<hive>LOCKS' | '<hive>METADATA' | '<hive>NONE' | '<hive>NOSCAN' | '<hive>OF' | '<hive>ORC' | '<hive>OUT' | '<hive>OUTPUTFORMAT' | '<hive>PARQUET' | '<hive>PARTITIONED' | '<hive>PARTITIONS' | '<hive>RCFILE' | '<hive>ROLE' | '<hive>ROLES' | '<hive>SCHEMA' | '<hive>SCHEMAS' | '<hive>SEQUENCEFILE' | '<hive>SERDE' | '<hive>SERDEPROPERTIES' | '<hive>SKEWED' | '<hive>SORTED' | '<hive>STORED' | '<hive>STORED_AS_DIRECTORIES' | '<hive>STRING' | '<hive>TABLES' | '<hive>TABLESAMPLE' | '<hive>TBLPROPERTIES' | '<hive>TEMPORARY' | '<hive>TERMINATED' | '<hive>TEXTFILE' | '<hive>TINYINT' | '<hive>TRANSACTIONS' | '<hive>UNIONTYPE' | '<hive>USING' | '<hive>VIEW' | '<hive>WINDOW' | '<hive>.' | '<hive>[' | '<hive>]'
- | '<impala>AGGREGATE' | '<impala>AVRO' | '<impala>CACHED' | '<impala>CLOSE_FN' | '<impala>COLUMN' | '<impala>COMMENT' | '<impala>DATA' | '<impala>DATABASES' | '<impala>DELIMITED' | '<impala>ESCAPED' | '<impala>EXTERNAL' | '<impala>FIELDS' | '<impala>FINALIZE_FN' | '<impala>FIRST' | '<impala>FORMAT' | '<impala>FORMATTED' | '<impala>FUNCTION' | '<impala>FUNCTIONS' | '<impala>GROUP' | '<impala>ILIKE' | '<impala>INCREMENTAL' | '<impala>INTERVAL' | '<impala>INIT_FN' | '<impala>INPATH' | '<impala>IREGEXP' | '<impala>LAST' | '<impala>LIMIT' | '<impala>LINES' | '<impala>LOCATION' | '<impala>MERGE_FN' | '<impala>NULLS' | '<impala>PARTITIONS' | '<impala>PREPARE_FN' | '<impala>RANGE' | '<impala>REAL' | '<impala>RETURNS' | '<impala>SCHEMAS' | '<impala>SERIALIZE_FN' | '<impala>STATS' | '<impala>STRAIGHT_JOIN' | '<impala>SYMBOL' | '<impala>TABLE' | '<impala>TABLES' | '<impala>USING' | '<impala>ANALYTIC' | '<impala>ANTI' | '<impala>CURRENT' | '<impala>GRANT' | '<impala>NOSHUFFLE' | '<impala>PARQUET' | '<impala>PARTITIONED' | '<impala>RCFILE' | '<impala>ROLE' | '<impala>ROLES' | '<impala>SEQUENCEFILE' | '<impala>SERDEPROPERTIES' | '<impala>SHUFFLE' | '<impala>STORED' | '<impala>TBLPROPERTIES' | '<impala>TERMINATED' | '<impala>TEXTFILE' | '<impala>UPDATE_FN' | '<impala>BROADCAST' | '<impala>...' | '<impala>.' | '<impala>[' | '<impala>]'
- | 'ALL' | 'ARRAY' | 'AS' | 'ASC' | 'BETWEEN' | 'BIGINT' | 'BOOLEAN' | 'BY' | 'CASE' | 'CHAR' | 'CROSS' | 'CURRENT' | 'DATABASE' | 'DECIMAL' | 'DISTINCT' | 'DOUBLE' | 'DESC' | 'ELSE' | 'END' | 'EXISTS' | 'FALSE' | 'FLOAT' | 'FOLLOWING' | 'FROM' | 'FULL' | 'GROUP' | 'HAVING' | 'IF' | 'IN' | 'INNER' | 'INSERT' | 'INT' | 'INTO' | 'IS' | 'JOIN' | 'LEFT' | 'LIKE' | 'LIMIT' | 'MAP' | 'NOT' | 'NULL' | 'ON' | 'ORDER' | 'OUTER' | 'OVER' | 'PARTITION' | 'PRECEDING' | 'RANGE' | 'REGEXP' | 'RIGHT' | 'RLIKE' | 'ROW' | 'ROWS' | 'SCHEMA' | 'SEMI' | 'SET' | 'SMALLINT' | 'STRING' | 'STRUCT' | 'TABLE' | 'THEN' | 'TIMESTAMP' | 'TINYINT' | 'TRUE' | 'UNION' | 'VALUES' | 'VARCHAR' | 'WHEN' | 'WHERE' | 'WITH' | 'ROLE'
- | 'AVG' | 'CAST' | 'COUNT' | 'MAX' | 'MIN' | 'STDDEV_POP' | 'STDDEV_SAMP' | 'SUM' | 'VARIANCE' | 'VAR_POP' | 'VAR_SAMP'
- | '<hive>COLLECT_SET' | '<hive>COLLECT_LIST' | '<hive>CORR' | '<hive>COVAR_POP' | '<hive>COVAR_SAMP' | '<hive>HISTOGRAM_NUMERIC' | '<hive>NTILE' | '<hive>PERCENTILE' | '<hive>PERCENTILE_APPROX'
- | '<impala>APPX_MEDIAN' | '<impala>EXTRACT' | '<impala>GROUP_CONCAT' | '<impala>STDDEV' | '<impala>VARIANCE_POP' | '<impala>VARIANCE_SAMP'
- | 'ANALYTIC'
- | 'UNSIGNED_INTEGER' | 'UNSIGNED_INTEGER_E' | 'REGULAR_IDENTIFIER' | 'HDFS_START_QUOTE' | 'AND' | 'OR' | '=' | '<' | '>' | 'COMPARISON_OPERATOR' | '-' | '*' | 'ARITHMETIC_OPERATOR' | ',' | '.' | '~' | '!' | '(' | ')' | '[' | ']' | 'VARIABLE_REFERENCE' | 'BACKTICK' | 'SINGLE_QUOTE' | 'DOUBLE_QUOTE'
- ;
-
-// ===================================== Commonly used constructs =====================================
-
-AggregateOrAnalytic
- : '<impala>AGGREGATE'
- | '<impala>ANALYTIC'
- ;
-
-Commas
- : ','
- | Commas ','
- ;
-
-AnyAs
- : 'AS'
- | '<hive>AS'
- ;
-
-AnyCreate
- : 'CREATE'
- | '<hive>CREATE'
- | '<impala>CREATE'
- ;
-
-AnyCursor
- : 'CURSOR'
- | 'PARTIAL_CURSOR'
- ;
-
-AnyDot
- : '.'
- | '<impala>.'
- | '<hive>.'
- ;
-
-AnyFromOrIn
- : 'FROM'
- | 'IN'
- ;
-
-AnyGroup
- : 'GROUP'
- | '<hive>GROUP'
- | '<impala>GROUP'
- ;
-
-AnyPartition
- : 'PARTITION'
- | '<hive>PARTITION'
- ;
-
-AnyTable
- : 'TABLE'
- | '<hive>TABLE'
- | '<impala>TABLE'
- ;
-
-DatabaseOrSchema
- : 'DATABASE'
- | 'SCHEMA'
- | '<hive>SCHEMA'
- ;
-
-FromOrIn
- : 'FROM'
- | 'IN'
- ;
-
-HiveIndexOrIndexes
- : '<hive>INDEX'
- | '<hive>INDEXES'
- ;
-
-HiveOrImpalaComment
- : '<hive>COMMENT'
- | '<impala>COMMENT'
- ;
-
-HiveOrImpalaCreate
- : '<hive>CREATE'
- | '<impala>CREATE'
- ;
-
-HiveOrImpalaDatabasesOrSchemas
- : '<hive>DATABASES'
- | '<hive>SCHEMAS'
- | '<impala>DATABASES'
- | '<impala>SCHEMAS'
- ;
-
-HiveOrImpalaEscaped
- : '<hive>ESCAPED'
- | '<impala>ESCAPED'
- ;
-
-HiveOrImpalaFields
- : '<hive>FIELDS'
- | '<impala>FIELDS'
- ;
-
-HiveOrImpalaFormat
- : '<hive>FORMAT'
- | '<impala>FORMAT'
- ;
-
-HiveOrImpalaLeftSquareBracket
- : '<hive>['
- | '<impala>['
- ;
-
-HiveOrImpalaLines
- : '<hive>LINES'
- | '<impala>LINES'
- ;
-
-HiveOrImpalaLocation
- : '<hive>LOCATION'
- | '<impala>LOCATION'
- ;
-
-HiveOrImpalaRightSquareBracket
- : '<hive>]'
- | '<impala>]'
- ;
-
-HiveOrImpalaPartitionedOrPartition
- : '<hive>PARTITIONED'
- | '<impala>PARTITIONED'
- | '<impala>PARTITION'
- ;
-
-HiveOrImpalaStored
- : '<hive>STORED'
- | '<impala>STORED'
- ;
-
-HiveOrImpalaTables
- : '<hive>TABLES'
- | '<impala>TABLES'
- ;
-
-HiveOrImpalaTblproperties
- : '<hive>TBLPROPERTIES'
- | '<impala>TBLPROPERTIES'
- ;
-
-HiveOrImpalaTerminated
- : '<hive>TERMINATED'
- | '<impala>TERMINATED'
- ;
-
-HiveRoleOrUser
- : '<hive>ROLE'
- | '<hive>USER'
- ;
-
-SingleQuotedValue
- : 'SINGLE_QUOTE' 'VALUE' 'SINGLE_QUOTE'  -> $2
- | 'SINGLE_QUOTE' 'SINGLE_QUOTE'          -> ''
- ;
-
-SingleQuotedValue_EDIT
- : 'SINGLE_QUOTE' 'PARTIAL_VALUE'
- ;
-
-DoubleQuotedValue
- : 'DOUBLE_QUOTE' 'VALUE' 'DOUBLE_QUOTE'  -> $2
- | 'DOUBLE_QUOTE' 'DOUBLE_QUOTE'          -> ''
- ;
-
-DoubleQuotedValue_EDIT
- : 'DOUBLE_QUOTE' 'PARTIAL_VALUE'
- ;
-
-QuotedValue
- : SingleQuotedValue
- | DoubleQuotedValue
- ;
-
-QuotedValue_EDIT
- : SingleQuotedValue_EDIT
- | DoubleQuotedValue_EDIT
- ;
-
-OptionalAggregateOrAnalytic
- :
- | AggregateOrAnalytic
- ;
-
-OptionalHiveExtended
- :
- | '<hive>EXTENDED'
- ;
-
-OptionalHiveExtendedOrFormatted
- :
- | '<hive>EXTENDED'
- | '<hive>FORMATTED'
- ;
-
-OptionalExternal
- :
- | '<hive>EXTERNAL'
- | '<impala>EXTERNAL'
- ;
-
-OptionalImpalaExtendedOrFormatted
- :
- | '<impala>EXTENDED'
- | '<impala>FORMATTED'
- ;
-
-OptionallyFormattedIndex
- : '<hive>FORMATTED' HiveIndexOrIndexes
- | HiveIndexOrIndexes
- ;
-
-OptionallyFormattedIndex_EDIT
- : '<hive>FORMATTED' 'CURSOR'
-   {
-     parser.suggestKeywords(['INDEX', 'INDEXES']);
-   }
- | 'CURSOR' HiveIndexOrIndexes
-   {
-     parser.suggestKeywords(['FORMATTED']);
-   }
- ;
-
-OptionalFromDatabase
- :
- | FromOrIn DatabaseIdentifier
- ;
-
-OptionalFromDatabase_EDIT
- : FromOrIn DatabaseIdentifier_EDIT
- ;
-
-OptionalHiveCascadeOrRestrict
- :
- | '<hive>CASCADE'
- | '<hive>RESTRICT'
- ;
-
-OptionalHiveTemporary
- :
- | '<hive>TEMPORARY'
- ;
-
-OptionalIfExists
- :
- | 'IF' 'EXISTS'
-   {
-     parser.yy.correlatedSubQuery = false;
-   }
- ;
-
-OptionalIfExists_EDIT
- : 'IF' 'CURSOR'
-   {
-     parser.suggestKeywords(['EXISTS']);
-   }
- ;
-
-OptionalIfNotExists
- :
- | 'IF' 'NOT' 'EXISTS'
-   {
-     parser.yy.correlatedSubQuery = false;
-   }
- ;
-
-OptionalIfNotExists_EDIT
- : 'IF' 'CURSOR'
-   {
-     parser.suggestKeywords(['NOT EXISTS']);
-   }
- | 'IF' 'NOT' 'CURSOR'
-   {
-     parser.suggestKeywords(['EXISTS']);
-   }
- ;
-
-OptionalInDatabase
- :
- | 'IN' DatabaseIdentifier
- | 'IN' DatabaseIdentifier_EDIT
- ;
-
-OptionalPartitionSpec
- :
- | PartitionSpec
- ;
-
-OptionalPartitionSpec_EDIT
- : PartitionSpec_EDIT
- ;
-
-PartitionSpec
- : AnyPartition '(' PartitionSpecList ')'
- ;
-
-PartitionSpec_EDIT
- : AnyPartition '(' PartitionSpecList_EDIT RightParenthesisOrError
- ;
-
-ConfigurationName
- : RegularIdentifier
- | 'CURSOR'
- | ConfigurationName '<hive>.' RegularIdentifier
- | ConfigurationName '<hive>.' 'PARTIAL_CURSOR'
- ;
-
-PartialBacktickedOrAnyCursor
- : AnyCursor
- | PartialBacktickedIdentifier
- ;
-
-PartialBacktickedOrCursor
- : 'CURSOR'
- | PartialBacktickedIdentifier
- ;
-
-PartialBacktickedOrPartialCursor
- : 'PARTIAL_CURSOR'
- | PartialBacktickedIdentifier
- ;
-
-PartialBacktickedIdentifier
- : 'BACKTICK' 'PARTIAL_VALUE'
- ;
-
-RightParenthesisOrError
- : ')'
- | error
- ;
-
-OptionalParenthesizedColumnList
- :
- | ParenthesizedColumnList
- ;
-
-OptionalParenthesizedColumnList_EDIT
- : ParenthesizedColumnList_EDIT
- ;
-
-ParenthesizedColumnList
- : '(' ColumnList ')'
- ;
-
-ParenthesizedColumnList_EDIT
- : '(' ColumnList_EDIT RightParenthesisOrError
- | '(' AnyCursor RightParenthesisOrError
-   {
-     parser.suggestColumns();
-   }
- ;
-
-ColumnList
- : ColumnIdentifier
- | ColumnList ',' ColumnIdentifier
- ;
-
-ColumnList_EDIT
- : ColumnIdentifier_EDIT
- | ColumnList ',' AnyCursor
-   {
-     parser.suggestColumns();
-   }
- | ColumnList ',' ColumnIdentifier_EDIT
- | ColumnIdentifier_EDIT ',' ColumnList
- | ColumnList ',' ColumnIdentifier_EDIT ',' ColumnList
- | ColumnList ',' AnyCursor ',' ColumnList
-   {
-     parser.suggestColumns();
-   }
- ;
-
-ParenthesizedSimpleValueList
- : '(' SimpleValueList ')'
- ;
-
-SimpleValueList
- : UnsignedValueSpecification
- | SimpleValueList ',' UnsignedValueSpecification
- ;
-
-SchemaQualifiedTableIdentifier
- : RegularOrBacktickedIdentifier
-   {
-     parser.addTableLocation(@1, [ { name: $1 } ]);
-     $$ = { identifierChain: [ { name: $1 } ] };
-   }
- | RegularOrBacktickedIdentifier AnyDot RegularOrBacktickedIdentifier
-   {
-     parser.addDatabaseLocation(@1, [ { name: $1 } ]);
-     parser.addTableLocation(@3, [ { name: $1 }, { name: $3 } ]);
-     $$ = { identifierChain: [ { name: $1 }, { name: $3 } ] };
-   }
- | RegularOrBacktickedIdentifier AnyDot RegularOrBacktickedIdentifier ImpalaFields
-   {
-     // This is a special case for Impala expression like "SELECT | FROM db.table.col"
-     $$ = { identifierChain: [ { name: $1 }, { name: $3 } ].concat($4) };
-   }
- ;
-
-SchemaQualifiedTableIdentifier_EDIT
- : PartialBacktickedIdentifier
-   {
-     parser.suggestTables();
-     parser.suggestDatabases({ appendDot: true });
-   }
- | PartialBacktickedIdentifier AnyDot RegularOrBacktickedIdentifier
-   {
-     parser.suggestDatabases();
-     $$ = { identifierChain: [{ name: $1 }] };
-   }
- | RegularOrBacktickedIdentifier AnyDot PartialBacktickedOrPartialCursor
-   {
-     // In Impala you can have statements like 'SELECT ... FROM testTable t, t.|'
-     parser.suggestTablesOrColumns($1);
-   }
- | RegularOrBacktickedIdentifier AnyDot RegularOrBacktickedIdentifier ImpalaFields_EDIT
-   {
-     // TODO: switch to suggestColumns, it's currently handled in sqlAutocompleter2.js
-     // Issue is that suggestColumns is deleted if no tables are defined and this is
-     // Impala only cases like "SELECT | FROM db.table.col"
-     parser.suggestTables({ identifierChain: [{ name: $1 }, { name: $3 }].concat($4) });
-   }
- ;
-
-ImpalaFields
- : ImpalaField               -> [$1]
- | ImpalaFields ImpalaField
-   {
-     $1.push($2);
-   }
- ;
-
-ImpalaFields_EDIT
- : ImpalaField_EDIT                            -> []
- | ImpalaFields ImpalaField_EDIT               -> $1
- | ImpalaFields ImpalaField_EDIT ImpalaFields  -> $1
- | ImpalaField_EDIT ImpalaFields               -> []
- ;
-
-ImpalaField
- : '<impala>.' RegularOrBacktickedIdentifier  -> { name: $2 }
- ;
-
-ImpalaField_EDIT
- : '<impala>.' PartialBacktickedOrPartialCursor
- ;
-
-SchemaQualifiedIdentifier
- : RegularOrBacktickedIdentifier
- | RegularOrBacktickedIdentifier AnyDot RegularOrBacktickedIdentifier
- ;
-
-SchemaQualifiedIdentifier_EDIT
- : PartialBacktickedIdentifier
-   {
-     parser.suggestDatabases({ appendDot: true });
-   }
- | PartialBacktickedIdentifier AnyDot RegularOrBacktickedIdentifier
-   {
-     parser.suggestDatabases();
-     $$ = { identifierChain: [{ name: $1 }] };
-   }
- | RegularOrBacktickedIdentifier AnyDot PartialBacktickedOrPartialCursor
- ;
-
-DatabaseIdentifier
- : RegularOrBacktickedIdentifier
- ;
-
-DatabaseIdentifier_EDIT
- : PartialBacktickedOrCursor
-   {
-     parser.suggestDatabases();
-   }
- ;
-
-PartitionSpecList
- : PartitionExpression
- | PartitionSpecList ',' PartitionExpression
- ;
-
-PartitionSpecList_EDIT
- : PartitionExpression_EDIT
- | PartitionSpecList ',' PartitionExpression_EDIT
- | PartitionExpression_EDIT ',' PartitionSpecList
- | PartitionSpecList ',' PartitionExpression_EDIT ',' PartitionSpecList
- ;
-
-PartitionExpression
- : ColumnIdentifier '=' ValueExpression
- | ColumnIdentifier // Hive allows partial partition specs in some cases
- ;
-
-PartitionExpression_EDIT
- : ColumnIdentifier '=' ValueExpression_EDIT
- | ColumnIdentifier '=' AnyCursor
-   {
-     parser.valueExpressionSuggest();
-   }
- | PartialBacktickedIdentifier '=' ValueExpression
-   {
-     parser.suggestColumns();
-   }
- | AnyCursor
-   {
-     parser.suggestColumns();
-   }
- ;
-
-RegularOrBacktickedIdentifier
- : RegularIdentifier
- | 'BACKTICK' 'VALUE' 'BACKTICK'  -> $2
- | 'BACKTICK' 'BACKTICK'          -> ''
- ;
-
-// TODO: Same as SchemaQualifiedTableIdentifier?
-RegularOrBackTickedSchemaQualifiedName
- : RegularOrBacktickedIdentifier
-   {
-     parser.addTableLocation(@1, [ { name: $1 } ]);
-     $$ = { identifierChain: [ { name: $1 } ] };
-   }
- | RegularOrBacktickedIdentifier AnyDot RegularOrBacktickedIdentifier
-   {
-     parser.addDatabaseLocation(@1, [ { name: $1 } ]);
-     parser.addTableLocation(@3, [ { name: $1 }, { name: $3 } ]);
-     $$ = { identifierChain: [ { name: $1 }, { name: $3 } ] };
-   }
- ;
-
-RegularOrBackTickedSchemaQualifiedName_EDIT
- : PartialBacktickedIdentifier
-   {
-     parser.suggestTables();
-     parser.suggestDatabases({ prependDot: true });
-   }
- | RegularOrBacktickedIdentifier AnyDot PartialBacktickedOrPartialCursor
-   {
-     parser.suggestTablesOrColumns($1);
-   }
- ;
-
-
-LocalOrSchemaQualifiedName
- : RegularOrBackTickedSchemaQualifiedName
- | RegularOrBackTickedSchemaQualifiedName RegularOrBacktickedIdentifier  -> { identifierChain: $1.identifierChain, alias: $2 }
- ;
-
-LocalOrSchemaQualifiedName_EDIT
- : RegularOrBackTickedSchemaQualifiedName_EDIT
- | RegularOrBackTickedSchemaQualifiedName_EDIT RegularOrBacktickedIdentifier
- ;
-
-ColumnReference
- : BasicIdentifierChain
-   {
-     parser.yy.locations[parser.yy.locations.length - 1].type = 'column';
-   }
- | BasicIdentifierChain AnyDot '*'
- ;
-
-ColumnReference_EDIT
- : BasicIdentifierChain_EDIT
- ;
-
-BasicIdentifierChain
- : ColumnIdentifier
-   {
-     $$ = [$1];
-     parser.addUnknownLocation(@1, [$1]);
-   }
- | BasicIdentifierChain AnyDot ColumnIdentifier
-   {
-     $1.push($3);
-     parser.addUnknownLocation(@3, $1.concat());
-   }
- ;
-
-// TODO: Merge with DerivedColumnChain_EDIT ( issue is starting with PartialBacktickedOrPartialCursor)
-BasicIdentifierChain_EDIT
- : ColumnIdentifier_EDIT
-   {
-     if ($1.insideKey) {
-       parser.suggestKeyValues({ identifierChain: [{ name: $1.name }] });
-       parser.suggestColumns();
-       parser.suggestFunctions();
-     }
-   }
- | BasicIdentifierChain AnyDot ColumnIdentifier_EDIT
-   {
-     if ($3.insideKey) {
-       parser.suggestKeyValues({ identifierChain: $1.concat({ name: $3.name }) });
-       parser.suggestColumns();
-       parser.suggestFunctions();
-     }
-   }
- | BasicIdentifierChain AnyDot ColumnIdentifier_EDIT AnyDot BasicIdentifierChain
- | ColumnIdentifier_EDIT AnyDot BasicIdentifierChain
- | BasicIdentifierChain AnyDot PartialBacktickedOrPartialCursor
-   {
-     parser.suggestColumns({
-       identifierChain: $1
-     });
-     $$ = { suggestKeywords: [{ value: '*', weight: 1000 }] };
-   }
- | BasicIdentifierChain AnyDot PartialBacktickedOrPartialCursor AnyDot BasicIdentifierChain
-   {
-     parser.suggestColumns({
-       identifierChain: $1
-     });
-     $$ = { suggestKeywords: [{ value: '*', weight: 1000 }] };
-   }
- ;
-
-DerivedColumnChain
- : ColumnIdentifier  -> [ $1 ]
- | DerivedColumnChain AnyDot ColumnIdentifier
-   {
-     $1.push($3);
-   }
- ;
-
-DerivedColumnChain_EDIT
- : ColumnIdentifier_EDIT
-   {
-     if ($1.insideKey) {
-       parser.suggestKeyValues({ identifierChain: [{ name: $1.name }] });
-       parser.suggestColumns();
-       parser.suggestFunctions();
-     }
-   }
- | DerivedColumnChain AnyDot ColumnIdentifier_EDIT
-   {
-     if ($3.insideKey) {
-       parser.suggestKeyValues({ identifierChain: $1.concat({ name: $3.name }) });
-       parser.suggestColumns();
-       parser.suggestFunctions();
-     }
-   }
- | DerivedColumnChain AnyDot ColumnIdentifier_EDIT AnyDot DerivedColumnChain
-   {
-     if ($3.insideKey) {
-       parser.suggestKeyValues({ identifierChain: $1.concat({ name: $3.name }) });
-       parser.suggestColumns();
-       parser.suggestFunctions();
-     }
-   }
- | ColumnIdentifier_EDIT AnyDot DerivedColumnChain
-   {
-     if ($1.insideKey) {
-       parser.suggestKeyValues({ identifierChain: [{ name: $1.name }] });
-       parser.suggestColumns();
-       parser.suggestFunctions();
-     }
-   }
- | PartialBacktickedIdentifierOrPartialCursor
-   {
-     parser.suggestColumns();
-   }
- | DerivedColumnChain AnyDot PartialBacktickedIdentifierOrPartialCursor
-   {
-     parser.suggestColumns({ identifierChain: $1 });
-   }
- | DerivedColumnChain AnyDot PartialBacktickedIdentifierOrPartialCursor AnyDot DerivedColumnChain
-   {
-     parser.suggestColumns({ identifierChain: $1 });
-   }
- | PartialBacktickedIdentifierOrPartialCursor AnyDot DerivedColumnChain
-   {
-     parser.suggestColumns();
-   }
- ;
-
-ColumnIdentifier
- : RegularOrBacktickedIdentifier OptionalMapOrArrayKey
-   {
-     if ($2) {
-       $$ = { name: $1, keySet: true };
-     } else {
-       $$ = { name: $1 };
-     }
-   }
- ;
-
-ColumnIdentifier_EDIT
- : RegularOrBacktickedIdentifier HiveOrImpalaLeftSquareBracket AnyCursor HiveOrImpalaRightSquareBracketOrError
-   {
-     $$ = { name: $1, insideKey: true }
-   }
- | RegularOrBacktickedIdentifier HiveOrImpalaLeftSquareBracket ValueExpression_EDIT HiveOrImpalaRightSquareBracketOrError
-   {
-     $$ = { name: $1 }
-   }
- ;
-
-PartialBacktickedIdentifierOrPartialCursor
- : PartialBacktickedIdentifier
- | 'PARTIAL_CURSOR'
- ;
-
-OptionalMapOrArrayKey
- :
- | HiveOrImpalaLeftSquareBracket ValueExpression HiveOrImpalaRightSquareBracket
- | HiveOrImpalaLeftSquareBracket HiveOrImpalaRightSquareBracket
- ;
-
-HiveOrImpalaRightSquareBracketOrError
- : HiveOrImpalaRightSquareBracket
- | error
- ;
-
-// TODO: Support | DECIMAL(precision, scale)  -- (Note: Available in Hive 0.13.0 and later)
-PrimitiveType
- : 'TINYINT'
- | '<hive>TINYINT'
- | 'SMALLINT'
- | 'INT'
- | 'BIGINT'
- | 'BOOLEAN'
- | 'FLOAT'
- | 'DOUBLE'
- | '<impala>REAL'
- | 'STRING'
- | '<hive>STRING'
- | 'DECIMAL' OptionalTypePrecision
- | 'CHAR' OptionalTypeLength
- | 'VARCHAR' OptionalTypeLength
- | 'TIMESTAMP'
- | '<hive>BINARY'
- | '<hive>DATE'
- ;
-
-OptionalTypeLength
- :
- | '(' 'UNSIGNED_INTEGER' ')'
- ;
-
-OptionalTypePrecision
- :
- | '(' 'UNSIGNED_INTEGER' ')'
- | '(' 'UNSIGNED_INTEGER' ',' 'UNSIGNED_INTEGER' ')'
- ;
-
-// ===================================== SELECT statement =====================================
-
-QuerySpecification
- : SelectStatement
- ;
-
-QuerySpecification_EDIT
- : SelectStatement_EDIT
- ;
-
-SelectStatement
- : 'SELECT' OptionalAllOrDistinct SelectList                  -> { selectList: $3 }
- | 'SELECT' OptionalAllOrDistinct SelectList TableExpression  -> { selectList: $3, tableExpression: $4 }
- ;
-
-SelectStatement_EDIT
- : 'SELECT' OptionalAllOrDistinct SelectList_EDIT
-   {
-     if ($3.cursorAtStart) {
-       var keywords = [];
-       if ($2) {
-         keywords = [{ value: '*', weight: 1000 }];
-       } else {
-         keywords = [{ value: '*', weight: 1000 }, 'ALL', 'DISTINCT'];
-       }
-       if (parser.isImpala()) {
-         keywords.push('STRAIGHT_JOIN');
-       }
-       parser.suggestKeywords(keywords);
-     } else {
-       parser.checkForSelectListKeywords($3);
-     }
-     if ($3.suggestFunctions) {
-       parser.suggestFunctions();
-     }
-     if ($3.suggestColumns) {
-       parser.suggestColumns();
-     }
-     if ($3.suggestTables) {
-       parser.suggestTables({ prependQuestionMark: true, prependFrom: true });
-     }
-     if ($3.suggestDatabases) {
-       parser.suggestDatabases({ prependQuestionMark: true, prependFrom: true, appendDot: true });
-     }
-     if ($3.suggestAggregateFunctions && (!$2 || $2 === 'ALL')) {
-       parser.suggestAggregateFunctions();
-       parser.suggestAnalyticFunctions();
-     }
-   }
- | 'SELECT' OptionalAllOrDistinct 'CURSOR'
-   {
-     var keywords = [];
-     if ($2) {
-       keywords = [{ value: '*', weight: 1000 }];
-       if ($2 === 'ALL') {
-         parser.suggestAggregateFunctions();
-         parser.suggestAnalyticFunctions();
-       }
-     } else {
-       keywords = [{ value: '*', weight: 1000 }, 'ALL', 'DISTINCT'];
-       parser.suggestAggregateFunctions();
-       parser.suggestAnalyticFunctions();
-     }
-     if (parser.isImpala()) {
-       keywords.push('STRAIGHT_JOIN');
-     }
-     parser.suggestKeywords(keywords);
-     parser.suggestFunctions();
-     parser.suggestColumns();
-     parser.suggestTables({ prependQuestionMark: true, prependFrom: true });
-     parser.suggestDatabases({ prependQuestionMark: true, prependFrom: true, appendDot: true });
-   }
- | 'SELECT' OptionalAllOrDistinct SelectList TableExpression_EDIT
- | 'SELECT' OptionalAllOrDistinct SelectList_EDIT TableExpression
-   {
-     parser.selectListNoTableSuggest($3, $2);
-   }
- | 'SELECT' OptionalAllOrDistinct 'CURSOR' TableExpression
-   {
-     var keywords = [];
-     if ($2) {
-       keywords = [{ value: '*', weight: 1000 }];
-       if ($2 === 'ALL') {
-         parser.suggestAggregateFunctions();
-         parser.suggestAnalyticFunctions();
-       }
-     } else {
-       keywords = [{ value: '*', weight: 1000 }, 'ALL', 'DISTINCT'];
-       parser.suggestAggregateFunctions();
-       parser.suggestAnalyticFunctions();
-     }
-     if (parser.isImpala()) {
-       keywords.push('STRAIGHT_JOIN');
-     }
-     parser.suggestKeywords(keywords);
-     parser.suggestFunctions();
-     parser.suggestColumns();
-     parser.suggestTables({ prependQuestionMark: true, prependFrom: true });
-     parser.suggestDatabases({ prependQuestionMark: true, prependFrom: true, appendDot: true });
-   }
- | 'SELECT' OptionalAllOrDistinct SelectList 'CURSOR' TableExpression
-   {
-     parser.checkForSelectListKeywords($3);
-   }
- | 'SELECT' OptionalAllOrDistinct SelectList 'CURSOR' ',' TableExpression
-   {
-     parser.checkForSelectListKeywords($3);
-   }
- | 'SELECT' OptionalAllOrDistinct SelectList 'CURSOR'
-   {
-     parser.checkForSelectListKeywords($3);
-     parser.suggestTables({ prependFrom: true });
-     parser.suggestDatabases({ prependFrom: true, appendDot: true });
-   }
- ;
-
-OptionalAllOrDistinct
- :
- | '<hive>ALL'
- | 'ALL'
- | 'DISTINCT'
- ;
-
-TableExpression
- : FromClause OptionalSelectConditions
- ;
-
-TableExpression_EDIT
- : FromClause_EDIT OptionalSelectConditions
- | FromClause 'CURSOR' OptionalSelectConditions OptionalJoins
-   {
-     var keywords = [];
-
-     if ($1) {
-       if (!$1.hasLateralViews && typeof $1.tableReferenceList.hasJoinCondition !== 'undefined' && !$1.tableReferenceList.hasJoinCondition) {
-         keywords.push({ value: 'ON', weight: 3 });
-         if (parser.isImpala()) {
-           keywords.push({ value: 'USING', weight: 3 });
-         }
-       }
-       if ($1.suggestKeywords) {
-         keywords = parser.createWeightedKeywords($1.suggestKeywords, 3);
-       }
-       if (!$1.hasLateralViews && $1.tableReferenceList.suggestKeywords) {
-         keywords = keywords.concat(parser.createWeightedKeywords($1.tableReferenceList.suggestKeywords, 3));
-       }
-
-       if (!$1.hasLateralViews && $1.tableReferenceList.types) {
-         var veKeywords = parser.getValueExpressionKeywords($1.tableReferenceList);
-         keywords = keywords.concat(veKeywords.suggestKeywords);
-         if (veKeywords.suggestColRefKeywords) {
-           parser.suggestColRefKeywords(veKeywords.suggestColRefKeywords);
-           parser.addColRefIfExists($1.tableReferenceList);
-         }
-       }
-     }
-
-     if ($3.empty && $4 && $4.joinType.toUpperCase() === 'JOIN') {
-       keywords = keywords.concat(['FULL', 'FULL OUTER', 'LEFT', 'LEFT OUTER', 'RIGHT', 'RIGHT OUTER']);
-       if (parser.isHive()) {
-         keywords = keywords.concat(['CROSS', 'LEFT SEMI']);
-       } else if (parser.isImpala()) {
-         keywords = keywords.concat(['INNER', 'LEFT ANTI', 'LEFT SEMI', 'RIGHT ANTI', 'RIGHT SEMI']);
-       } else {
-         keywords.push('INNER');
-       }
-       parser.suggestKeywords(keywords);
-       return;
-     }
-
-     if ($3.suggestKeywords) {
-       keywords = keywords.concat(parser.createWeightedKeywords($3.suggestKeywords, 2));
-     }
-
-     if ($3.empty) {
-       keywords.push({ value: 'UNION', weight: 2.11 });
-     }
-
-     keywords = keywords.concat([{ value: 'FULL JOIN', weight: 1 }, { value: 'FULL OUTER JOIN', weight: 1 }, { value: 'JOIN', weight: 1 }, { value: 'LEFT JOIN', weight: 1 }, { value: 'LEFT OUTER JOIN', weight: 1 }, { value: 'RIGHT JOIN', weight: 1 }, { value: 'RIGHT OUTER JOIN', weight: 1 }]);
-     if (parser.isHive()) {
-       keywords = keywords.concat([{ value: 'CROSS JOIN', weight: 1 }, { value: 'LEFT SEMI JOIN', weight: 1 }]);
-     } else if (parser.isImpala()) {
-       keywords = keywords.concat([{ value: 'INNER JOIN', weight: 1 },  { value: 'LEFT ANTI JOIN', weight: 1 }, { value: 'LEFT SEMI JOIN', weight: 1 }, { value: 'RIGHT ANTI JOIN', weight: 1 }, { value: 'RIGHT SEMI JOIN', weight: 1 }]);
-     } else {
-       keywords.push({ value: 'INNER JOIN', weight: 1 });
-     }
-     parser.suggestKeywords(keywords);
-  }
- | FromClause OptionalSelectConditions_EDIT OptionalJoins
-   {
-     // A couple of things are going on here:
-     // - If there are no SelectConditions (WHERE, GROUP BY, etc.) we should suggest complete join options
-     // - If there's an OptionalJoin at the end, i.e. 'SELECT * FROM foo | JOIN ...' we should suggest
-     //   different join types
-     // - The FromClause could end with a valueExpression, in which case we should suggest keywords like '='
-     //   or 'AND' based on type
-
-     if (!$2) {
-       return;
-     }
-     var keywords = [];
-
-     if ($2.suggestColRefKeywords) {
-       parser.suggestColRefKeywords($2.suggestColRefKeywords);
-       parser.addColRefIfExists($2);
-     }
-
-     if ($2.suggestKeywords && $2.suggestKeywords.length) {
-       keywords = keywords.concat(parser.createWeightedKeywords($2.suggestKeywords, 2));
-     }
-
-     if ($2.cursorAtEnd) {
-       keywords.push({ value: 'UNION', weight: 2.11 });
-     }
-     parser.suggestKeywords(keywords);
-   }
- ;
-
-OptionalJoins
- :
- | Joins
- | Joins_INVALID
- ;
-
-FromClause
- : 'FROM' TableReferenceList OptionalLateralViews
-   {
-     if (parser.isHive()) {
-       $$ = { tableReferenceList : $2, suggestKeywords: ['LATERAL VIEW'] }
-     } else {
-       $$ = { tableReferenceList : $2 }
-     }
-     if (parser.isHive() && $3) {
-       parser.yy.lateralViews = $3.lateralViews;
-       $$.hasLateralViews = true;
-       if ($3.suggestKeywords) {
-         $$.suggestKeywords = $$.suggestKeywords.concat($3.suggestKeywords);
-       }
-     }
-   }
- ;
-
-FromClause_EDIT
- : 'FROM' 'CURSOR'
-   {
-       parser.suggestTables();
-       parser.suggestDatabases({ appendDot: true });
-   }
- | 'FROM' TableReferenceList_EDIT OptionalLateralViews
-   {
-     if ($3) {
-       parser.yy.lateralViews = $3.lateralViews;
-     }
-   }
- | 'FROM' TableReferenceList OptionalLateralViews_EDIT
- ;
-
-OptionalSelectConditions
- : OptionalWhereClause OptionalGroupByClause OptionalHavingClause OptionalWindowClause OptionalOrderByClause OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
-   {
-     var keywords = parser.getKeywordsForOptionalsLR([$1, $2, $3, $4, $5, $6, $7, $8], [{ value: 'WHERE', weight: 9 }, { value: 'GROUP BY', weight: 8 }, { value: 'HAVING', weight: 7 }, { value: 'WINDOW', weight: 6 }, { value: 'ORDER BY', weight: 5 }, [{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }, { value: 'SORT BY', weight: 4 }], { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, true, true, parser.isHive(), true, parser.isHive(), true, parser.isImpala()]);
-     if (keywords.length > 0) {
-       $$ = { suggestKeywords: keywords, empty: !$1 && !$2 && !$3 && !$4 && !$5 && !$6 && !$7 && !$8 }
-     }
-   }
- ;
-
-OptionalSelectConditions_EDIT
- : WhereClause_EDIT OptionalGroupByClause OptionalHavingClause OptionalWindowClause OptionalOrderByClause OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
- | OptionalWhereClause GroupByClause_EDIT OptionalHavingClause OptionalWindowClause OptionalOrderByClause OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
- | OptionalWhereClause OptionalGroupByClause HavingClause_EDIT OptionalWindowClause OptionalOrderByClause OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
- | OptionalWhereClause OptionalGroupByClause OptionalHavingClause WindowClause_EDIT OptionalOrderByClause OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
- | OptionalWhereClause OptionalGroupByClause OptionalHavingClause OptionalWindowClause OrderByClause_EDIT OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
- | OptionalWhereClause OptionalGroupByClause OptionalHavingClause OptionalWindowClause OptionalOrderByClause ClusterOrDistributeBy_EDIT OptionalLimitClause OptionalOffsetClause
- | OptionalWhereClause OptionalGroupByClause OptionalHavingClause OptionalWindowClause OptionalOrderByClause OptionalClusterOrDistributeBy LimitClause_EDIT OptionalOffsetClause
- | OptionalWhereClause OptionalGroupByClause OptionalHavingClause OptionalWindowClause OptionalOrderByClause OptionalClusterOrDistributeBy OptionalLimitClause OffsetClause_EDIT
- ;
-
-OptionalSelectConditions_EDIT
- : WhereClause 'CURSOR' OptionalGroupByClause OptionalHavingClause OptionalWindowClause OptionalOrderByClause OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
-   {
-     var keywords = parser.getKeywordsForOptionalsLR([$3, $4, $5, $6, $7, $8, $9], [{ value: 'GROUP BY', weight: 8 }, { value: 'HAVING', weight: 7 }, { value: 'WINDOW', weight: 6 }, { value: 'ORDER BY', weight: 5 }, [{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }, { value: 'SORT BY', weight: 4 }], { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, true, parser.isHive(), true, parser.isHive(), true, parser.isImpala()]);
-     if ($1.suggestKeywords) {
-       keywords = keywords.concat(parser.createWeightedKeywords($1.suggestKeywords, 1));
-     }
-     $$ = parser.getValueExpressionKeywords($1, keywords);
-     $$.cursorAtEnd = !$3 && !$4 && !$5 && !$6 && !$7 && !$8 && !$9;
-     if ($1.columnReference) {
-       $$.columnReference = $1.columnReference;
-     }
-   }
- | OptionalWhereClause GroupByClause 'CURSOR' OptionalHavingClause OptionalWindowClause OptionalOrderByClause OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
-   {
-     var keywords = parser.getKeywordsForOptionalsLR([$4, $5, $6, $7, $8, $9], [{ value: 'HAVING', weight: 7 }, { value: 'WINDOW', weight: 6 }, { value: 'ORDER BY', weight: 5 }, [{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }, { value: 'SORT BY', weight: 4 }], { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, parser.isHive(), true, parser.isHive(), true, parser.isImpala()]);
-     if ($2.suggestKeywords) {
-       keywords = keywords.concat(parser.createWeightedKeywords($2.suggestKeywords, 8));
-     }
-     $$ = parser.getValueExpressionKeywords($2, keywords);
-     if ($2.columnReference) {
-       $$.columnReference = $2.columnReference;
-     }
-     $$.cursorAtEnd = !$4 && !$5 && !$6 && !$7 && !$8 && !$9;
-   }
- | OptionalWhereClause OptionalGroupByClause HavingClause 'CURSOR' OptionalWindowClause OptionalOrderByClause OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
-   {
-     var keywords = parser.getKeywordsForOptionalsLR([$5, $6, $7, $8, $9], [{ value: 'WINDOW', weight: 6 }, { value: 'ORDER BY', weight: 5 }, [{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }, { value: 'SORT BY', weight: 4 }], { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [parser.isHive(), true, parser.isHive(), true, parser.isImpala()]);
-     $$ = { suggestKeywords: keywords, cursorAtEnd: !$5 && !$6 && !$7 && !$8 && !$9 };
-   }
- | OptionalWhereClause OptionalGroupByClause OptionalHavingClause WindowClause 'CURSOR' OptionalOrderByClause OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
-   {
-     var keywords = parser.getKeywordsForOptionalsLR([$6, $7, $8, $9], [{ value: 'ORDER BY', weight: 5 }, [{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }, { value: 'SORT BY', weight: 4 }], { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, parser.isHive(), true, parser.isImpala()]);
-     $$ = { suggestKeywords: keywords, cursorAtEnd: !$6 && !$7 && !$8 && !$9 };
-   }
- | OptionalWhereClause OptionalGroupByClause OptionalHavingClause OptionalWindowClause OrderByClause 'CURSOR' OptionalClusterOrDistributeBy OptionalLimitClause OptionalOffsetClause
-   {
-     var keywords = parser.getKeywordsForOptionalsLR([$7, $8, $9], [[{ value: 'CLUSTER BY', weight: 4 }, { value: 'DISTRIBUTE BY', weight: 4 }, { value: 'SORT BY', weight: 4 }], { value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [parser.isHive(), true, parser.isImpala()]);
-     if ($5.suggestKeywords) {
-       keywords = keywords.concat(parser.createWeightedKeywords($5.suggestKeywords, 5));
-     }
-     $$ = { suggestKeywords: keywords, cursorAtEnd: !$7 && !$8 && !$9 };
-   }
- | OptionalWhereClause OptionalGroupByClause OptionalHavingClause OptionalWindowClause OptionalOrderByClause ClusterOrDistributeBy 'CURSOR' OptionalLimitClause OptionalOffsetClause
-   {
-     var keywords = parser.getKeywordsForOptionalsLR([$8, $9], [{ value: 'LIMIT', weight: 3 }, { value: 'OFFSET', weight: 2 }], [true, parser.isImpala()]);
-     if ($6.suggestKeywords) {
-       keywords = keywords.concat(parser.createWeightedKeywords($6.suggestKeywords, 4));
-     }
-     $$ = { suggestKeywords: keywords, cursorAtEnd: !$8 && !$9 };
-   }
- | OptionalWhereClause OptionalGroupByClause OptionalHavingClause OptionalWindowClause OptionalOrderByClause OptionalClusterOrDistributeBy LimitClause 'CURSOR' OptionalOffsetClause
-   {
-     var keywords = parser.getKeywordsForOptionalsLR([$9], [{ value: 'OFFSET', weight: 2 }], [parser.isImpala()]);
-     $$ = { suggestKeywords: keywords, cursorAtEnd: !$9 };
-   }
- ;
-
-OptionalWhereClause
- :
- | WhereClause
- ;
-
-WhereClause
- : 'WHERE' SearchCondition  -> $2
- ;
-
-WhereClause_EDIT
- : 'WHERE' SearchCondition_EDIT
- | 'WHERE' 'CURSOR'
-   {
-     parser.suggestFunctions();
-     parser.suggestColumns();
-     parser.suggestKeywords(['EXISTS', 'NOT EXISTS']);
-   }
- ;
-
-OptionalGroupByClause
- :
- | GroupByClause
- ;
-
-GroupByClause
- : AnyGroup 'BY' GroupByColumnList OptionalHiveGroupingSetsCubeOrRollup
-   {
-     if (!$4) {
-       $$ = $3;
-       if (parser.isHive()) {
-         if (!$$.suggestKeywords) {
-           $$.suggestKeywords = [];
-         }
-         $$.suggestKeywords.push('GROUPING SETS');
-         $$.suggestKeywords.push('WITH CUBE');
-         $$.suggestKeywords.push('WITH ROLLUP');
-       }
-     }
-   }
- ;
-
-GroupByClause_EDIT
- : AnyGroup 'BY' GroupByColumnList_EDIT OptionalHiveGroupingSetsCubeOrRollup
-   {
-     parser.suggestSelectListAliases();
-   }
- | AnyGroup 'BY' 'CURSOR' OptionalHiveGroupingSetsCubeOrRollup
-   {
-     parser.valueExpressionSuggest();
-     parser.suggestSelectListAliases();
-   }
- | AnyGroup 'CURSOR'
-   {
-     parser.suggestKeywords(['BY']);
-   }
- | AnyGroup 'BY' GroupByColumnList OptionalHiveGroupingSetsCubeOrRollup_EDIT
- ;
-
-OptionalHiveGroupingSetsCubeOrRollup
- :
- | HiveGroupingSets
- | 'WITH' '<hive>CUBE'
- | 'WITH' '<hive>ROLLUP'
- ;
-
-OptionalHiveGroupingSetsCubeOrRollup_EDIT
- : HiveGroupingSets_EDIT
- | 'WITH' 'CURSOR'
-   {
-     if (parser.isHive()) {
-       parser.suggestKeywords(['CUBE', 'ROLLUP']);
-     }
-   }
- ;
-
-HiveGroupingSets
- : '<hive>GROUPING' '<hive>SETS' '(' ColumnGroupingSets ')'
- ;
-
-HiveGroupingSets_EDIT
- : '<hive>GROUPING' 'CURSOR'
-   {
-     parser.suggestKeywords(['SETS']);
-   }
- | '<hive>GROUPING' '<hive>SETS' '(' ColumnGroupingSets_EDIT RightParenthesisOrError
- ;
-
-ColumnGroupingSets
- :
- | ColumnReference
- | ColumnGroupingSets ',' ColumnGroupingSets
- | '(' ColumnGroupingSets ')'
- ;
-
-ColumnGroupingSets_EDIT
- : ColumnGroupingSet_EDIT
- | ColumnGroupingSet_EDIT ',' ColumnGroupingSets
- | ColumnGroupingSets ',' ColumnGroupingSet_EDIT
- | ColumnGroupingSets ',' ColumnGroupingSet_EDIT ',' ColumnGroupingSets
- | '(' ColumnGroupingSets_EDIT RightParenthesisOrError
- ;
-
-ColumnGroupingSet_EDIT
- : AnyCursor
-   {
-     parser.suggestColumns();
-   }
- | ColumnReference_EDIT
- ;
-
-GroupByColumnList
- : ValueExpression
- | GroupByColumnList ',' ValueExpression  -> $3
- ;
-
-GroupByColumnList_EDIT
- : ValueExpression_EDIT
- | 'CURSOR' ValueExpression
-   {
-     parser.valueExpressionSuggest();
-   }
- | 'CURSOR' ',' GroupByColumnList
-   {
-     parser.valueExpressionSuggest();
-   }
- | ValueExpression_EDIT ',' GroupByColumnList
- | GroupByColumnList ',' GroupByColumnListPartTwo_EDIT
- | GroupByColumnList ',' GroupByColumnListPartTwo_EDIT ','
- | GroupByColumnList ',' GroupByColumnListPartTwo_EDIT ',' GroupByColumnList
- ;
-
-GroupByColumnListPartTwo_EDIT
- : ValueExpression_EDIT
- | AnyCursor ValueExpression
-   {
-     parser.valueExpressionSuggest();
-   }
- | AnyCursor
-   {
-     parser.valueExpressionSuggest();
-   }
- ;
-
-OptionalOrderByClause
- :
- | OrderByClause
- ;
-
-OrderByClause
- : 'ORDER' 'BY' OrderByColumnList  -> $3
- ;
-
-OrderByClause_EDIT
- : 'ORDER' 'BY' OrderByColumnList_EDIT
- | 'ORDER' 'CURSOR'
-   {
-     parser.suggestKeywords(['BY']);
-   }
- ;
-
-OrderByColumnList
- : OrderByIdentifier
- | OrderByColumnList ',' OrderByIdentifier  -> $3
- ;
-
-OrderByColumnList_EDIT
- : OrderByIdentifier_EDIT
- | 'CURSOR' OrderByIdentifier
-   {
-     parser.valueExpressionSuggest();
-     parser.suggestAnalyticFunctions();
-     parser.suggestSelectListAliases();
-   }
- | OrderByColumnList ',' OrderByIdentifier_EDIT
- | OrderByColumnList ',' OrderByIdentifier_EDIT ','
- | OrderByColumnList ',' OrderByIdentifier_EDIT ',' OrderByColumnList
- ;
-
-OrderByIdentifier
- : ValueExpression OptionalAscOrDesc OptionalImpalaNullsFirstOrLast  -> parser.mergeSuggestKeywords($2, $3)
- ;
-
-OrderByIdentifier_EDIT
- : ValueExpression_EDIT OptionalAscOrDesc OptionalImpalaNullsFirstOrLast
-   {
-     parser.suggestSelectListAliases();
-   }
- | ValueExpression OptionalAscOrDesc OptionalImpalaNullsFirstOrLast_EDIT
- | AnyCursor OptionalAscOrDesc OptionalImpalaNullsFirstOrLast
-   {
-     parser.valueExpressionSuggest();
-     parser.suggestAnalyticFunctions();
-     parser.suggestSelectListAliases();
-   }
- ;
-
-OptionalAscOrDesc
- :
-  {
-    $$ = { suggestKeywords: ['ASC', 'DESC'] };
-  }
- | 'ASC'
- | '<hive>ASC'
- | 'DESC'
- | '<hive>DESC'
- ;
-
-OptionalImpalaNullsFirstOrLast
- :
-  {
-    if (parser.isImpala()) {
-      $$ = { suggestKeywords: ['NULLS FIRST', 'NULLS LAST'] };
-    } else {
-      $$ = {};
-    }
-  }
- | '<impala>NULLS' '<impala>FIRST'
- | '<impala>NULLS' '<impala>LAST'
- ;
-
-OptionalImpalaNullsFirstOrLast_EDIT
- : '<impala>NULLS' 'CURSOR'
-   {
-     parser.suggestKeywords(['FIRST', 'LAST']);
-   }
- ;
-
-OptionalClusterOrDistributeBy
- :
- | ClusterOrDistributeBy
- ;
-
-ClusterOrDistributeBy
- : ClusterByClause
- | DistributeByClause               -> { suggestKeywords: ['SORT BY'] }
- | DistributeByClause SortByClause
- | SortByClause
- ;
-
-ClusterOrDistributeBy_EDIT
- : ClusterByClause_EDIT
- | DistributeByClause_EDIT
- | DistributeByClause SortByClause_EDIT
- | DistributeByClause_EDIT SortByClause
- | SortByClause_EDIT
- ;
-
-ClusterByClause
- : '<hive>CLUSTER' 'BY' ColumnList
- ;
-
-ClusterByClause_EDIT
- : '<hive>CLUSTER' 'CURSOR'
-   {
-     suggestKeywords: ['BY'];
-   }
- | '<hive>CLUSTER' 'BY' 'CURSOR'
-   {
-     parser.suggestColumns();
-     parser.suggestSelectListAliases();
-   }
- | '<hive>CLUSTER' 'BY' ColumnList_EDIT
-   {
-     parser.suggestSelectListAliases();
-   }
- ;
-
-DistributeByClause
- : '<hive>DISTRIBUTE' 'BY' ColumnList
- ;
-
-DistributeByClause_EDIT
- : '<hive>DISTRIBUTE' 'CURSOR'
-   {
-     suggestKeywords: ['BY'];
-   }
- | '<hive>DISTRIBUTE' 'BY' 'CURSOR'
-   {
-     parser.suggestColumns();
-     parser.suggestSelectListAliases();
-   }
- | '<hive>DISTRIBUTE' 'BY' ColumnList_EDIT
-   {
-     parser.suggestSelectListAliases();
-   }
- ;
-
-SortByClause
- : '<hive>SORT' 'BY' SortByList  -> $3
- ;
-
-SortByClause_EDIT
- : '<hive>SORT' 'CURSOR'
-   {
-     suggestKeywords: ['BY'];
-   }
- | '<hive>SORT' 'BY' SortByList_EDIT
-   {
-     parser.suggestSelectListAliases();
-   }
- ;
-
-SortByList
- : SortByIdentifier
- | SortByList ',' SortByIdentifier  -> $3
- ;
-
-SortByList_EDIT
- : SortByIdentifier_EDIT
- | SortByIdentifier_EDIT ',' SortByList
- | SortByList ',' SortByIdentifier_EDIT
- | SortByList ',' SortByIdentifier_EDIT ',' SortByList
- ;
-
-SortByIdentifier
- : ColumnIdentifier OptionalAscOrDesc  -> $2
- ;
-
-SortByIdentifier_EDIT
- : ColumnIdentifier_EDIT OptionalAscOrDesc
- | AnyCursor OptionalAscOrDesc
-   {
-     parser.suggestColumns();
-   }
- ;
-
-OptionalLimitClause
- :
- | LimitClause
- ;
-
-LimitClause
- : 'LIMIT' UnsignedNumericLiteral
- | '<impala>LIMIT' ValueExpression
- ;
-
-LimitClause_EDIT
- : 'LIMIT' 'CURSOR'
- | '<impala>LIMIT' 'CURSOR'
-   {
-     parser.suggestFunctions({ types: ['BIGINT'] });
-   }
- | '<impala>LIMIT' ValueExpression_EDIT
-   {
-     delete parser.yy.result.suggestColumns;
-   }
- ;
-
-OptionalOffsetClause
- :
- | OffsetClause
- ;
-
-OffsetClause
- : '<impala>OFFSET' ValueExpression
- ;
-
-OffsetClause_EDIT
- : '<impala>OFFSET' 'CURSOR'
-   {
-     parser.suggestFunctions({ types: ['BIGINT'] });
-   }
- | '<impala>OFFSET' ValueExpression_EDIT
-   {
-     delete parser.yy.result.suggestColumns;
-   }
- ;
-
-SearchCondition
- : ValueExpression
- ;
-
-SearchCondition_EDIT
- : ValueExpression_EDIT
- ;
-
-ValueExpression
- : NonParenthesizedValueExpressionPrimary
- ;
-
-ValueExpression_EDIT
- : NonParenthesizedValueExpressionPrimary_EDIT
- ;
-
-ValueExpression_EDIT
- : ValueExpression 'NOT' 'CURSOR'
-   {
-     if (parser.isImpala()) {
-       parser.suggestKeywords(['BETWEEN', 'EXISTS', 'IN', 'ILIKE', 'IREGEXP', 'LIKE', 'REGEXP', 'RLIKE']);
-     } else {
-       parser.suggestKeywords(['BETWEEN', 'EXISTS', 'IN', 'LIKE', 'REGEXP', 'RLIKE']);
-     }
-     $$ = { types: [ 'BOOLEAN' ] };
-   }
- ;
-
-ValueExpressionList
- : ValueExpression
-   {
-     $1.position = 1;
-   }
- | ValueExpressionList ',' ValueExpression
-   {
-     $3.position = $1.position + 1;
-     $$ = $3;
-   }
- ;
-
-ValueExpressionList_EDIT
- : ValueExpression_EDIT
-   {
-     $1.position = 1;
-   }
- | ValueExpressionList ',' ValueExpression_EDIT
-   {
-     $1.position += 1;
-   }
- | ValueExpression_EDIT ',' ValueExpressionList
-   {
-     $1.position = 1;
-   }
- | ValueExpressionList ',' ValueExpression_EDIT ',' ValueExpressionList
-   {
-     // $3.position = $1.position + 1;
-     // $$ = $3
-     $1.position += 1;
-   }
- | ValueExpressionList ',' AnyCursor
-   {
-     parser.valueExpressionSuggest();
-     $1.position += 1;
-   }
- | ValueExpressionList ',' AnyCursor ',' ValueExpressionList
-   {
-     parser.valueExpressionSuggest();
-     $1.position += 1;
-   }
- | ValueExpressionList 'CURSOR' ',' ValueExpressionList
-   {
-     parser.suggestValueExpressionKeywords($1);
-   }
- | AnyCursor ',' ValueExpressionList
-   {
-     parser.valueExpressionSuggest();
-     $$ = { cursorAtStart : true, position: 1 };
-   }
- | AnyCursor ','
-   {
-     parser.valueExpressionSuggest();
-     $$ = { cursorAtStart : true, position: 1 };
-   }
- | ',' AnyCursor
-   {
-     parser.valueExpressionSuggest();
-     $$ = { position: 2 };
-   }
- | ',' AnyCursor ',' ValueExpressionList
-   {
-     parser.valueExpressionSuggest();
-     $$ = { position: 2 };
-   }
- ;
-
-InValueList
- : NonParenthesizedValueExpressionPrimary
- | InValueList ',' NonParenthesizedValueExpressionPrimary
- ;
-
-NonParenthesizedValueExpressionPrimary
- : UnsignedValueSpecification
- | ColumnReference             -> { types: ['COLREF'], columnReference: $1 }
- | UserDefinedFunction
- | 'NULL'                      -> { types: [ 'NULL' ] }
- | ImpalaInterval              -> { types: [ 'TIMESTAMP' ] }
- ;
-
-NonParenthesizedValueExpressionPrimary_EDIT
- : UnsignedValueSpecification_EDIT
- | ColumnReference_EDIT
-   {
-     if ($1.suggestKeywords) {
-       $$ = { types: ['COLREF'], columnReference: $1, suggestKeywords: $1.suggestKeywords };
-     } else {
-       $$ = { types: ['COLREF'], columnReference: $1 };
-     }
-   }
- | UserDefinedFunction_EDIT
- | ImpalaInterval_EDIT
- ;
-
-ImpalaInterval
- : '<impala>INTERVAL' SignedInteger RegularIdentifier
- ;
-
-ImpalaInterval_EDIT
- : '<impala>INTERVAL' SignedInteger 'CURSOR'
-   {
-     parser.suggestKeywords(['DAYS', 'HOURS', 'MICROSECONDS', 'MILLISECONDS', 'MINUTES', 'MONTHS', 'NANOSECONDS', 'SECONDS', 'WEEKS', 'YEARS']);
-   }
- ;
-
-SignedInteger
- : UnsignedNumericLiteral
- | '-' UnsignedNumericLiteral
- | '+' UnsignedNumericLiteral
- ;
-
-UnsignedValueSpecification
- : UnsignedLiteral
- ;
-
-UnsignedValueSpecification_EDIT
- : UnsignedLiteral_EDIT
-   {
-     parser.suggestValues($1);
-   }
- ;
-
-UnsignedLiteral
- : UnsignedNumericLiteral  -> { types: [ 'NUMBER' ] }
- | GeneralLiteral
- ;
-
-UnsignedLiteral_EDIT
- : GeneralLiteral_EDIT
- ;
-
-UnsignedNumericLiteral
- : ExactNumericLiteral
- | ApproximateNumericLiteral
- ;
-
-ExactNumericLiteral
- : 'UNSIGNED_INTEGER'
- | 'UNSIGNED_INTEGER' AnyDot
- | 'UNSIGNED_INTEGER' AnyDot 'UNSIGNED_INTEGER'
- | AnyDot 'UNSIGNED_INTEGER'
- ;
-
-ApproximateNumericLiteral
- : UNSIGNED_INTEGER_E 'UNSIGNED_INTEGER'
- | AnyDot UNSIGNED_INTEGER_E 'UNSIGNED_INTEGER'
- | 'UNSIGNED_INTEGER' AnyDot UNSIGNED_INTEGER_E 'UNSIGNED_INTEGER'
- ;
-
-GeneralLiteral
- : SingleQuotedValue  -> { types: [ 'STRING' ] }
- | DoubleQuotedValue  -> { types: [ 'STRING' ] }
- | TruthValue         -> { types: [ 'BOOLEAN' ] }
- ;
-
-GeneralLiteral_EDIT
- : SingleQuotedValue_EDIT
-  {
-    $$ = { partialQuote: '\'', missingEndQuote: parser.yy.missingEndQuote };
-  }
- | DoubleQuotedValue_EDIT
-  {
-    $$ = { partialQuote: '"', missingEndQuote: parser.yy.missingEndQuote };
-  }
- ;
-
-TruthValue
- : 'TRUE'
- | 'FALSE'
- ;
-
-OptionalNot
- :
- | 'NOT'
- ;
-
-SelectSpecification
- : ValueExpression OptionalCorrelationName
-   {
-     if ($2) {
-       $$ = { valueExpression: $1, alias: $2 };
-       if (!parser.yy.selectListAliases) {
-         parser.yy.selectListAliases = [];
-       }
-       parser.yy.selectListAliases.push({ name: $2, types: $1.types || ['T'] });
-     } else {
-       $$ = { valueExpression: $1 }
-     }
-   }
- | '*'
-   {
-     $$ = { asterisk: true }
-   }
- ;
-
-SelectSpecification_EDIT
- : ValueExpression_EDIT OptionalCorrelationName
- | AnyCursor AnyAs RegularOrBacktickedIdentifier
-   {
-     parser.suggestFunctions();
-     parser.suggestColumns();
-     $$ = { suggestAggregateFunctions: true };
-   }
- | ValueExpression OptionalCorrelationName_EDIT  -> $2
- ;
-
-SelectList
- : SelectSpecification                 -> [ $1 ]
- | SelectList ',' SelectSpecification
-   {
-     $1.push($3);
-   }
- ;
-
-SelectList_EDIT
- : SelectSpecification_EDIT
- | 'CURSOR' SelectList
-   {
-     $$ = { cursorAtStart : true, suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true };
-   }
- | 'CURSOR' ',' SelectList
-   {
-     $$ = { cursorAtStart : true, suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true };
-   }
- | SelectSpecification_EDIT ',' SelectList
- | SelectList 'CURSOR' SelectList
-   {
-     parser.checkForSelectListKeywords($1);
-   }
- | SelectList 'CURSOR' ',' SelectList
-   {
-     parser.checkForSelectListKeywords($1);
-   }
- | SelectList ',' AnyCursor
-   {
-     $$ = { suggestKeywords: [{ value: '*', weight: 1000 }], suggestTables: true, suggestDatabases: true, suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true };
-   }
- | SelectList ',' SelectSpecification_EDIT                 -> $3
- | SelectList ',' AnyCursor SelectList
-   {
-     $$ = { suggestKeywords: [{ value: '*', weight: 1000 }], suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true,  };
-   }
- | SelectList ',' AnyCursor ','
-   {
-     $$ = { suggestKeywords: [{ value: '*', weight: 1000 }], suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true,  };
-   }
- | SelectList ',' SelectSpecification_EDIT ','             -> $3
- | SelectList ',' AnyCursor ',' SelectList
-   {
-     $$ = { suggestKeywords: [{ value: '*', weight: 1000 }], suggestFunctions: true, suggestColumns: true, suggestAggregateFunctions: true,  };
-   }
- | SelectList ',' SelectSpecification_EDIT ',' SelectList  -> $3
- ;
-
-TableReferenceList
- : TableReference
- | TableReferenceList ',' TableReference  -> $3
- ;
-
-TableReferenceList_EDIT
- : TableReference_EDIT
- | TableReference_EDIT ',' TableReference
- | TableReferenceList ',' TableReference_EDIT
- | TableReferenceList ',' TableReference_EDIT ',' TableReferenceList
- | TableReferenceList ',' AnyCursor
-   {
-       parser.suggestTables();
-       parser.suggestDatabases({ appendDot: true });
-   }
- ;
-
-TableReference
- : TablePrimaryOrJoinedTable
- ;
-
-TableReference_EDIT
- : TablePrimaryOrJoinedTable_EDIT
- ;
-
-TablePrimaryOrJoinedTable
- : TablePrimary
- | JoinedTable
- ;
-
-TablePrimaryOrJoinedTable_EDIT
- : TablePrimary_EDIT
- | JoinedTable_EDIT
- ;
-
-JoinedTable
- : TablePrimary Joins  -> $2
- ;
-
-JoinedTable_EDIT
- : TablePrimary Joins_EDIT
- | TablePrimary_EDIT Joins
- ;
-
-Joins
- : JoinTypes OptionalImpalaBroadcastOrShuffle TablePrimary OptionalJoinCondition
-   {
-     $4.joinType = $1;
-     $$ = $4;
-   }
- | Joins JoinTypes OptionalImpalaBroadcastOrShuffle TablePrimary OptionalJoinCondition
-   {
-     $5.joinType = $1;
-     $$ = $5;
-   }
- ;
-
-Joins_INVALID
- : JoinTypes OptionalImpalaBroadcastOrShuffle                                           -> { joinType: $1 }
- | JoinTypes OptionalImpalaBroadcastOrShuffle Joins                                     -> { joinType: $1 }
- ;
-
-OptionalImpalaBroadcastOrShuffle
- :
- | '<impala>BROADCAST'
- | '<impala>SHUFFLE'
- ;
-
-Join_EDIT
- : JoinTypes_EDIT OptionalImpalaBroadcastOrShuffle TablePrimary OptionalJoinCondition
- | JoinTypes_EDIT OptionalImpalaBroadcastOrShuffle
- | JoinTypes OptionalImpalaBroadcastOrShuffle TablePrimary_EDIT OptionalJoinCondition
- | JoinTypes OptionalImpalaBroadcastOrShuffle TablePrimary JoinCondition_EDIT
- | JoinTypes OptionalImpalaBroadcastOrShuffle 'CURSOR' OptionalJoinCondition
-   {
-     if (!$2 && parser.isImpala()) {
-       parser.suggestKeywords(['[BROADCAST]', '[SHUFFLE]']);
-     }
-     parser.suggestTables();
-     parser.suggestDatabases({
-       appendDot: true
-     });
-   }
- ;
-
-Joins_EDIT
- : Join_EDIT
- | Join_EDIT Joins
- | Joins Join_EDIT
- | Joins Join_EDIT Joins
- ;
-
-JoinTypes
- : 'JOIN'
- | 'CROSS' 'JOIN'
- | 'INNER' 'JOIN'
- | 'FULL' 'JOIN'
- | 'FULL' 'OUTER' 'JOIN'
- | 'LEFT' 'JOIN'
- | 'LEFT' '<impala>ANTI' 'JOIN'
- | 'LEFT' 'OUTER' 'JOIN'
- | 'LEFT' 'SEMI' 'JOIN'
- | 'RIGHT' 'JOIN'
- | 'RIGHT' '<impala>ANTI' 'JOIN'
- | 'RIGHT' 'OUTER' 'JOIN'
- | 'RIGHT' 'SEMI' 'JOIN'
- ;
-
-JoinTypes_EDIT
- : 'CROSS' 'CURSOR'
-   {
-     parser.suggestKeywords(['JOIN']);
-   }
- | 'INNER' 'CURSOR'
-   {
-     parser.suggestKeywords(['JOIN']);
-   }
- | 'FULL' 'OUTER' 'CURSOR'
-   {
-     parser.suggestKeywords(['JOIN']);
-   }
- | 'FULL' 'CURSOR' 'JOIN'
-   {
-     parser.suggestKeywords(['OUTER']);
-   }
- | 'LEFT' 'SEMI' 'CURSOR'
-   {
-     parser.suggestKeywords(['JOIN']);
-   }
- | 'LEFT' 'OUTER' 'CURSOR'
-   {
-     parser.suggestKeywords(['JOIN']);
-   }
- | 'LEFT' '<impala>ANTI' 'CURSOR'
-   {
-     parser.suggestKeywords(['JOIN']);
-   }
- | 'LEFT' 'CURSOR' 'JOIN'
-   {
-     if (parser.isImpala()) {
-       parser.suggestKeywords(['ANTI', 'OUTER', 'SEMI']);
-     } else if (parser.isHive()) {
-       parser.suggestKeywords(['OUTER', 'SEMI']);
-     } else {
-       parser.suggestKeywords(['OUTER']);
-     }
-   }
- | 'RIGHT' '<impala>ANTI' 'CURSOR'
-   {
-     parser.suggestKeywords(['JOIN']);
-   }
- | 'RIGHT' 'OUTER' 'CURSOR'
-   {
-     parser.suggestKeywords(['JOIN']);
-   }
- | 'RIGHT' 'SEMI' 'CURSOR'
-   {
-     parser.suggestKeywords(['JOIN']);
-   }
- | 'RIGHT' 'CURSOR' 'JOIN'
-   {
-     if (parser.isImpala()) {
-       parser.suggestKeywords(['ANTI', 'SEMI', 'OUTER']);
-     } else {
-       parser.suggestKeywords(['OUTER']);
-     }
-   }
- ;
-
-OptionalJoinCondition
- :                       -> { suggestKeywords: parser.isImpala() ? ['ON', 'USING'] : ['ON'] }
- | 'ON' ValueExpression  -> $2
- | '<impala>USING' '(' UsingColList ')'
- ;
-
-UsingColList
- : RegularOrBacktickedIdentifier
- | UsingColList ',' RegularOrBacktickedIdentifier
- ;
-
-JoinCondition_EDIT
- : 'ON' ValueExpression_EDIT
- | 'ON' 'CURSOR'
-   {
-     parser.valueExpressionSuggest();
-   }
- ;
-
-TablePrimary
- : TableOrQueryName OptionalTableSample OptionalCorrelationName
-   {
-     if ($1.identifierChain) {
-       if ($3) {
-         $1.alias = $3
-       }
-       parser.addTablePrimary($1);
-     }
-     // Right-to-left for cursor after TablePrimary
-     $$.suggestKeywords = parser.getKeywordsForOptionalsLR([$3, $2], [{ value: 'AS', weight: 1 }, { value: 'TABLESAMPLE', weight: 2 }], [true, parser.isHive()]);
-   }
- | DerivedTable OptionalCorrelationName
-   {
-     if ($2) {
-       $1.alias = $2;
-       parser.addTablePrimary({ subQueryAlias: $2 });
-     } else {
-       $$.suggestKeywords = [{ value: 'AS', weight: 1 }];
-     }
-   }
- ;
-
-TablePrimary_EDIT
- : TableOrQueryName_EDIT OptionalTableSample OptionalCorrelationName
- | TableOrQueryName OptionalTableSample_EDIT OptionalCorrelationName
-   {
-     if ($3) {
-       $1.alias = $3;
-     }
-     parser.addTablePrimary($1);
-   }
- | DerivedTable_EDIT OptionalCorrelationName
-   {
-     if ($2) {
-       parser.addTablePrimary({ subQueryAlias: $2 });
-     }
-   }
- | DerivedTable OptionalCorrelationName_EDIT
- ;
-
-TableOrQueryName
- : SchemaQualifiedTableIdentifier
- ;
-
-TableOrQueryName_EDIT
- : SchemaQualifiedTableIdentifier_EDIT
- ;
-
-DerivedTable
- : TableSubQuery
- ;
-
-DerivedTable_EDIT
- : TableSubQuery_EDIT
- ;
-
-OptionalTableSample
- :
- | '<hive>TABLESAMPLE' '(' '<hive>BUCKET' 'UNSIGNED_INTEGER' '<hive>OUT' '<hive>OF' 'UNSIGNED_INTEGER' OptionalOnColumn ')'
- ;
-
-OptionalTableSample_EDIT
- : '<hive>TABLESAMPLE' '(' AnyCursor RightParenthesisOrError
-   {
-     parser.suggestKeywords(['BUCKET']);
-   }
- | '<hive>TABLESAMPLE' '(' '<hive>BUCKET' 'UNSIGNED_INTEGER' 'CURSOR' RightParenthesisOrError
-   {
-     parser.suggestKeywords(['OUT OF']);
-   }
- | '<hive>TABLESAMPLE' '(' '<hive>BUCKET' 'UNSIGNED_INTEGER' '<hive>OUT' 'CURSOR' RightParenthesisOrError
-   {
-     parser.suggestKeywords(['OF']);
-   }
- | '<hive>TABLESAMPLE' '(' '<hive>BUCKET' 'UNSIGNED_INTEGER' '<hive>OUT' '<hive>OF' 'UNSIGNED_INTEGER' OptionalOnColumn 'CURSOR' RightParenthesisOrError
-   {
-     if (!$8) {
-       parser.suggestKeywords(['ON']);
-     }
-   }
- | '<hive>TABLESAMPLE' '(' '<hive>BUCKET' 'UNSIGNED_INTEGER' '<hive>OUT' '<hive>OF' 'UNSIGNED_INTEGER' OptionalOnColumn_EDIT RightParenthesisOrError
- ;
-
-OptionalOnColumn
- :
- | 'ON' ValueExpression
- ;
-
-OptionalOnColumn_EDIT
- : 'ON' 'CURSOR'
-   {
-     parser.valueExpressionSuggest();
-   }
- | 'ON' ValueExpression_EDIT
- ;
-
-PushQueryState
- :
-   {
-     parser.pushQueryState();
-   }
- ;
-
-PopQueryState
- :
-   {
-     parser.popQueryState();
-   }
- ;
-
-TableSubQuery
- : '(' TableSubQueryInner ')'  -> $2
- | '(' DerivedTable OptionalCorrelationName ')'
-   {
-     if ($3) {
-       $2.alias = $3;
-       parser.addTablePrimary({ subQueryAlias: $3 });
-     }
-     $$ = $2;
-   }
- ;
-
-TableSubQuery_EDIT
- : '(' TableSubQueryInner_EDIT RightParenthesisOrError
- | '(' AnyCursor RightParenthesisOrError
-   {
-     parser.suggestKeywords(['SELECT']);
-   }
- ;
-
-TableSubQueryInner
- : PushQueryState SubQuery
-   {
-     var subQuery = parser.getSubQuery($2);
-     subQuery.columns.forEach(function (column) {
-       parser.expandIdentifierChain(column);
-       delete column.linked;
-     });
-     parser.popQueryState(subQuery);
-     $$ = subQuery;
-   }
- ;
-
-TableSubQueryInner_EDIT
- : PushQueryState SubQuery_EDIT PopQueryState
- ;
-
-SubQuery
- : QueryExpression
- ;
-
-SubQuery_EDIT
- : QueryExpression_EDIT
- ;
-
-QueryExpression
- : QueryExpressionBody
- ;
-
-QueryExpression_EDIT
- : QueryExpressionBody_EDIT
- ;
-
-QueryExpressionBody
- : NonJoinQueryExpression
- ;
-
-QueryExpressionBody_EDIT
- : NonJoinQueryExpression_EDIT
- ;
-
-NonJoinQueryExpression
- : NonJoinQueryTerm
- ;
-
-NonJoinQueryExpression_EDIT
- : NonJoinQueryTerm_EDIT
- ;
-
-NonJoinQueryTerm
- : NonJoinQueryPrimary
- ;
-
-NonJoinQueryTerm_EDIT
- : NonJoinQueryPrimary_EDIT
- ;
-
-NonJoinQueryPrimary
- : SimpleTable
- ;
-
-NonJoinQueryPrimary_EDIT
- : SimpleTable_EDIT
- ;
-
-SimpleTable
- : QuerySpecification
- ;
-
-SimpleTable_EDIT
- : QuerySpecification_EDIT
- ;
-
-OptionalCorrelationName
- :
- | RegularOrBacktickedIdentifier
- | AnyAs RegularOrBacktickedIdentifier  -> $2
- ;
-
-OptionalCorrelationName_EDIT
- : PartialBacktickedIdentifier
- | AnyAs PartialBacktickedIdentifier
- | AnyAs 'CURSOR'
- ;
-
-OptionalLateralViews
- :
- | OptionalLateralViews LateralView
-   {
-     if ($1 && $2.lateralView) {
-       $1.lateralViews.push($2.lateralView);
-       $$ = $1;
-     } else if ($2.lateralView) {
-       $$ = { lateralViews: [ $2.lateralView ] };
-     }
-     if ($2.suggestKeywords) {
-       $$.suggestKeywords = $2.suggestKeywords
-     }
-   }
- ;
-
-OptionalLateralViews_EDIT
- : OptionalLateralViews LateralView_EDIT OptionalLateralViews
- ;
-
-UserDefinedFunction
- : ArbitraryFunction
- | AggregateFunction OptionalOverClause
-   {
-     if (!$2) {
-       $1.suggestKeywords = ['OVER'];
-     }
-   }
- | AnalyticFunction OverClause
- | CastFunction
- | ExtractFunction
- ;
-
-UserDefinedFunction_EDIT
- : ArbitraryFunction_EDIT
- | AggregateFunction_EDIT
- | AggregateFunction OptionalOverClause_EDIT
- | AnalyticFunction_EDIT
- | AnalyticFunction_EDIT OverClause
- | AnalyticFunction 'CURSOR'
-   {
-     parser.suggestKeywords(['OVER']);
-   }
- | AnalyticFunction OverClause_EDIT
- | CastFunction_EDIT
- | ExtractFunction_EDIT
- ;
-
-ArbitraryFunction
- : RegularIdentifier ArbitraryFunctionRightPart
-   {
-     parser.addFunctionLocation(@1, $1);
-     if ($2.expression) {
-       $$ = { function: $1, expression: $2.expression, types: parser.findReturnTypes($1) }
-     } else {
-       $$ = { function: $1, types: parser.findReturnTypes($1) }
-     }
-   }
- | ArbitraryFunctionName ArbitraryFunctionRightPart
-   {
-     parser.addFunctionLocation(@1, $1);
-     if ($2.expression) {
-       $$ = { function: $1, expression: $2.expression, types: parser.findReturnTypes($1) }
-     } else {
-       $$ = { function: $1, types: parser.findReturnTypes($1) }
-     }
-   }
- ;
-
-ArbitraryFunction_EDIT
- : RegularIdentifier ArbitraryFunctionRightPart_EDIT
-   {
-     parser.addFunctionLocation(@1, $1);
-     if ($2.position) {
-       parser.applyArgumentTypesToSuggestions($1, $2.position);
-     }
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | ArbitraryFunctionName ArbitraryFunctionRightPart_EDIT
-   {
-     parser.addFunctionLocation(@1, $1);
-     if ($2.position) {
-       parser.applyArgumentTypesToSuggestions($1, $2.position);
-     }
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- ;
-
-ArbitraryFunctionName
- : 'IF'
- | 'ARRAY'
- | '<hive>BINARY'
- | 'MAP'
- ;
-
-ArbitraryFunctionRightPart
- : '(' ')'
- | '(' ValueExpressionList ')'  -> { expression: $2 }
- ;
-
-ArbitraryFunctionRightPart_EDIT
- : '(' AnyCursor RightParenthesisOrError
-   {
-     parser.valueExpressionSuggest();
-     $$ = { position: 1 }
-   }
- | '(' ValueExpressionList 'CURSOR' RightParenthesisOrError
-   {
-     parser.suggestValueExpressionKeywords($3);
-   }
- | '(' ValueExpressionList_EDIT RightParenthesisOrError      -> $2
- ;
-
-AggregateFunction
- : CountFunction
- | SumFunction
- | OtherAggregateFunction
- ;
-
-AggregateFunction_EDIT
- : CountFunction_EDIT
- | SumFunction_EDIT
- | OtherAggregateFunction_EDIT
- ;
-
-AnalyticFunction
- : 'ANALYTIC' '(' ')'                      -> { types: parser.findReturnTypes($1) }
- | 'ANALYTIC' '(' ValueExpressionList ')'  -> { function: $1, expression: $2, types: parser.findReturnTypes($1) }
- ;
-
-AnalyticFunction_EDIT
- : 'ANALYTIC' '(' AnyCursor RightParenthesisOrError
-   {
-     parser.valueExpressionSuggest();
-     parser.applyArgumentTypesToSuggestions($1, 1);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | 'ANALYTIC' '(' ValueExpressionList 'CURSOR' RightParenthesisOrError
-   {
-     parser.suggestValueExpressionKeywords($3);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | 'ANALYTIC' '(' ValueExpressionList_EDIT RightParenthesisOrError
-   {
-     parser.applyArgumentTypesToSuggestions($1, $3.position);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- ;
-
-OptionalOverClause
- :
- | OverClause
- ;
-
-OptionalOverClause_EDIT
- : OverClause_EDIT
- ;
-
-OverClause
- : 'OVER' RegularOrBacktickedIdentifier
- | 'OVER' WindowExpression
- ;
-
-OverClause_EDIT
- : 'OVER' WindowExpression_EDIT
- ;
-
-WindowExpression
- : '(' OptionalPartitionBy OptionalOrderByAndWindow ')'
- ;
-
-WindowExpression_EDIT
- : '(' PartitionBy_EDIT OptionalOrderByAndWindow RightParenthesisOrError
- | '(' OptionalPartitionBy OptionalOrderByAndWindow_EDIT RightParenthesisOrError
- | '(' AnyCursor OptionalPartitionBy OptionalOrderByAndWindow RightParenthesisOrError
-   {
-     if (!$3 && !$4) {
-       parser.suggestKeywords([{ value: 'PARTITION BY', weight: 2 }, { value: 'ORDER BY', weight: 1 }]);
-     } else if (!$3) {
-       parser.suggestKeywords(['PARTITION BY']);
-     }
-   }
- | '(' AnyPartition 'BY' ValueExpressionList 'CURSOR' OptionalOrderByAndWindow RightParenthesisOrError
-    {
-      if (!$6) {
-        parser.suggestValueExpressionKeywords($4, [{ value: 'ORDER BY', weight: 2 }]);
-      } else {
-        parser.suggestValueExpressionKeywords($4);
-      }
-    }
-  ;
-
-OptionalPartitionBy
- :
- | PartitionBy
- ;
-
-PartitionBy
- : AnyPartition 'BY' ValueExpressionList  -> $3
- ;
-
-PartitionBy_EDIT
- : AnyPartition 'CURSOR'
-   {
-     parser.suggestKeywords(['BY']);
-   }
- | AnyPartition 'BY' 'CURSOR'
-   {
-     parser.valueExpressionSuggest();
-   }
- | AnyPartition 'BY' ValueExpressionList_EDIT
- ;
-
-OptionalOrderByAndWindow
- :
- | OrderByClause OptionalWindowSpec
- ;
-
-OptionalOrderByAndWindow_EDIT
-  : OrderByClause_EDIT
-    {
-      // Only allowed in last order by
-      delete parser.yy.result.suggestAnalyticFunctions;
-    }
-  | OrderByClause 'CURSOR' OptionalWindowSpec
-    {
-      var keywords = [];
-      if ($1.suggestKeywords) {
-        keywords = parser.createWeightedKeywords($1.suggestKeywords, 2);
-      }
-      if (!$3) {
-        keywords = keywords.concat([{ value: 'RANGE BETWEEN', weight: 1 }, { value: 'ROWS BETWEEN', weight: 1 }]);
-      }
-      parser.suggestKeywords(keywords);
-    }
-  | OrderByClause WindowSpec_EDIT
-  ;
-
-OptionalWindowSpec
- :
- | WindowSpec
- ;
-
-WindowSpec
- : RowsOrRange 'BETWEEN' PopLexerState OptionalCurrentOrPreceding OptionalAndFollowing
- ;
-
-WindowSpec_EDIT
- : RowsOrRange 'CURSOR'
-   {
-     parser.suggestKeywords(['BETWEEN']);
-   }
- | RowsOrRange 'BETWEEN' PopLexerState OptionalCurrentOrPreceding OptionalAndFollowing 'CURSOR'
-   {
-     if (!$4 && !$5) {
-       parser.suggestKeywords(['CURRENT ROW', 'UNBOUNDED PRECEDING']);
-     } else if (!$5) {
-       parser.suggestKeywords(['AND']);
-     }
-   }
- | RowsOrRange 'BETWEEN' PopLexerState OptionalCurrentOrPreceding_EDIT OptionalAndFollowing
- | RowsOrRange 'BETWEEN' PopLexerState OptionalCurrentOrPreceding OptionalAndFollowing_EDIT
- ;
-
-PopLexerState
- :
-  {
-    lexer.popState();
-  }
- ;
-
-PushHdfsLexerState
- :
-  {
-    lexer.begin('hdfs');
-  }
- ;
-
-RowsOrRange
- : 'ROWS'
- | AnyRange
- ;
-
-OptionalCurrentOrPreceding
- :
- | IntegerOrUnbounded 'PRECEDING'
- | AnyCurrent 'ROW'
- ;
-
-OptionalCurrentOrPreceding_EDIT
- : IntegerOrUnbounded 'CURSOR'
-   {
-     parser.suggestKeywords(['PRECEDING']);
-   }
- | AnyCurrent 'CURSOR'
-   {
-     parser.suggestKeywords(['ROW']);
-   }
- ;
-
-AnyCurrent
- : 'CURRENT'
- | '<hive>CURRENT'
- | '<impala>CURRENT'
- ;
-
-OptionalAndFollowing
- :
- | 'AND' AnyCurrent 'ROW'
- | 'AND' IntegerOrUnbounded 'FOLLOWING'
- ;
-
-OptionalAndFollowing_EDIT
- : 'AND' 'CURSOR'
-   {
-     parser.suggestKeywords(['CURRENT ROW', 'UNBOUNDED FOLLOWING']);
-   }
- | 'AND' AnyCurrent 'CURSOR'
-   {
-     parser.suggestKeywords(['ROW']);
-   }
- | 'AND' IntegerOrUnbounded 'CURSOR'
-   {
-     parser.suggestKeywords(['FOLLOWING']);
-   }
- ;
-
-IntegerOrUnbounded
- : 'UNSIGNED_INTEGER'
- | 'UNBOUNDED'
- ;
-
-OptionalHavingClause
- :
- | HavingClause
- ;
-
-HavingClause
- : 'HAVING' ValueExpression
- ;
-
-HavingClause_EDIT
- : 'HAVING' 'CURSOR'
-   {
-     parser.valueExpressionSuggest();
-     parser.suggestAggregateFunctions();
-     parser.suggestSelectListAliases(true);
-   }
- | 'HAVING' ValueExpression_EDIT
-   {
-     parser.suggestAggregateFunctions();
-     parser.suggestSelectListAliases(true);
-   }
- ;
-
-OptionalWindowClause
- :
- | WindowClause
- ;
-
-WindowClause
- : '<hive>WINDOW' RegularOrBacktickedIdentifier '<hive>AS' WindowExpression
- ;
-
-WindowClause_EDIT
- : '<hive>WINDOW' RegularOrBacktickedIdentifier 'CURSOR'
-   {
-     parser.suggestKeywords(['AS']);
-   }
- | '<hive>WINDOW' RegularOrBacktickedIdentifier '<hive>AS' WindowExpression_EDIT
- ;
-
-CastFunction
- : 'CAST' '(' ValueExpression AnyAs PrimitiveType ')'  -> { types: [ $5.toUpperCase() ] }
- | 'CAST' '(' ')'                                      -> { types: [ 'T' ] }
- ;
-
-CastFunction_EDIT
- : 'CAST' '(' AnyCursor AnyAs PrimitiveType RightParenthesisOrError
-   {
-     parser.valueExpressionSuggest();
-     $$ = { types: [ $5.toUpperCase() ] };
-   }
- | 'CAST' '(' AnyCursor AnyAs RightParenthesisOrError
-   {
-     parser.valueExpressionSuggest();
-     $$ = { types: [ 'T' ] };
-   }
- | 'CAST' '(' AnyCursor RightParenthesisOrError
-   {
-     parser.valueExpressionSuggest();
-     $$ = { types: [ 'T' ] };
-   }
- | 'CAST' '(' ValueExpression_EDIT AnyAs PrimitiveType RightParenthesisOrError  -> { types: [ $5.toUpperCase() ] }
- | 'CAST' '(' ValueExpression_EDIT AnyAs RightParenthesisOrError                -> { types: [ 'T' ] }
- | 'CAST' '(' ValueExpression_EDIT RightParenthesisOrError                      -> { types: [ 'T' ] }
- | 'CAST' '(' ValueExpression 'CURSOR' PrimitiveType RightParenthesisOrError
-   {
-     parser.suggestValueExpressionKeywords($3, [{ value: 'AS', weight: 2 }]);
-     $$ =  { types: [ $5.toUpperCase() ] };
-   }
- | 'CAST' '(' ValueExpression 'CURSOR' RightParenthesisOrError
-   {
-     parser.suggestValueExpressionKeywords($3, [{ value: 'AS', weight: 2 }]);
-     $$ = { types: [ 'T' ] };
-   }
- | 'CAST' '(' ValueExpression AnyAs 'CURSOR' RightParenthesisOrError
-   {
-     parser.suggestKeywords(parser.getTypeKeywords());
-     $$ = { types: [ 'T' ] };
-   }
- | 'CAST' '(' AnyAs 'CURSOR' RightParenthesisOrError
-   {
-     parser.suggestKeywords(parser.getTypeKeywords());
-     $$ = { types: [ 'T' ] };
-   }
- ;
-
-CountFunction
- : 'COUNT' '(' '*' ')'                                        -> { types: parser.findReturnTypes($1) }
- | 'COUNT' '(' ')'                                            -> { types: parser.findReturnTypes($1) }
- | 'COUNT' '(' OptionalAllOrDistinct ValueExpressionList ')'  -> { types: parser.findReturnTypes($1) }
- ;
-
-CountFunction_EDIT
- : 'COUNT' '(' OptionalAllOrDistinct AnyCursor RightParenthesisOrError
-   {
-     parser.valueExpressionSuggest();
-     if (!$3) {
-       var keywords = parser.isImpala() ? [{ value: '*', weight: 1000 }, 'ALL', 'DISTINCT'] : [{ value: '*', weight: 1000 }, 'DISTINCT'];
-       if (parser.yy.result.suggestKeywords) {
-         keywords = parser.yy.result.suggestKeywords.concat(keywords);
-       }
-       parser.suggestKeywords(keywords);
-     }
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | 'COUNT' '(' OptionalAllOrDistinct ValueExpressionList 'CURSOR' RightParenthesisOrError
-   {
-     parser.suggestValueExpressionKeywords($4);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | 'COUNT' '(' OptionalAllOrDistinct ValueExpressionList_EDIT RightParenthesisOrError
-   {
-     if ($4.cursorAtStart && !$3) {
-       if (parser.isImpala()) {
-         parser.suggestKeywords(['ALL', 'DISTINCT']);
-       } else {
-         parser.suggestKeywords(['DISTINCT']);
-       }
-     }
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- ;
-
-OtherAggregateFunction
- : OtherAggregateFunction_Type '(' OptionalAllOrDistinct ')'                      -> { types: parser.findReturnTypes($1) }
- | OtherAggregateFunction_Type '(' OptionalAllOrDistinct ValueExpressionList ')'  -> { types: parser.findReturnTypes($1) }
- ;
-
-OtherAggregateFunction_EDIT
- : OtherAggregateFunction_Type '(' OptionalAllOrDistinct AnyCursor RightParenthesisOrError
-   {
-     parser.valueExpressionSuggest();
-     if (!$3) {
-       var keywords = [];
-       if ($1.toLowerCase() === 'group_concat') {
-         keywords = ['ALL'];
-       } else if (parser.isImpala()) {
-         keywords = ['ALL', 'DISTINCT'];
-       } else {
-         keywords = ['DISTINCT'];
-       }
-       if (parser.yy.result.suggestKeywords) {
-         keywords = parser.yy.result.suggestKeywords.concat(keywords);
-       }
-       parser.suggestKeywords(keywords);
-     }
-     parser.applyArgumentTypesToSuggestions($1, 1);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | OtherAggregateFunction_Type '(' OptionalAllOrDistinct ValueExpressionList 'CURSOR' RightParenthesisOrError
-   {
-     parser.suggestValueExpressionKeywords($4);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | OtherAggregateFunction_Type '(' OptionalAllOrDistinct ValueExpressionList_EDIT RightParenthesisOrError
-   {
-     if ($4.cursorAtStart && !$3) {
-       var keywords = [];
-       if ($1.toLowerCase() === 'group_concat') {
-         keywords = ['ALL'];
-       } else if (parser.isImpala()) {
-         keywords = ['ALL', 'DISTINCT'];
-       } else {
-         keywords = ['DISTINCT'];
-       }
-       if (parser.yy.result.suggestKeywords) {
-         keywords = parser.yy.result.suggestKeywords.concat(keywords);
-       }
-       parser.suggestKeywords(keywords);
-     }
-     if (parser.yy.result.suggestFunctions && !parser.yy.result.suggestFunctions.types) {
-       parser.applyArgumentTypesToSuggestions($1, $4.position);
-     }
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- ;
-
-OtherAggregateFunction_Type
- : '<impala>APPX_MEDIAN'
- | 'AVG'
- | '<hive>COLLECT_SET'
- | '<hive>COLLECT_LIST'
- | '<hive>CORR'
- | '<hive>COVAR_POP'
- | '<hive>COVAR_SAMP'
- | '<impala>GROUP_CONCAT'
- | '<hive>HISTOGRAM_NUMERI'
- | '<impala>STDDEV'
- | 'STDDEV_POP'
- | 'STDDEV_SAMP'
- | 'MAX'
- | 'MIN'
- | '<hive>NTILE'
- | '<hive>PERCENTILE'
- | '<hive>PERCENTILE_APPROX'
- | 'VARIANCE'
- | '<impala>VARIANCE_POP'
- | '<impala>VARIANCE_SAMP'
- | 'VAR_POP'
- | 'VAR_SAMP'
- ;
-
-ExtractFunction
- : '<impala>EXTRACT' '(' ValueExpression FromOrComma ValueExpression ')'
- | '<impala>EXTRACT' '(' ')'
- ;
-
-ExtractFunction_EDIT
- : '<impala>EXTRACT' '(' AnyCursor FromOrComma ValueExpression RightParenthesisOrError
-   {
-     parser.valueExpressionSuggest();
-     parser.applyTypeToSuggestions($4.toLowerCase() === 'from' ? ['STRING'] : ['TIMESTAMP']);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | '<impala>EXTRACT' '(' AnyCursor FromOrComma RightParenthesisOrError
-   {
-     parser.valueExpressionSuggest();
-     parser.applyTypeToSuggestions($4.toLowerCase() === 'from' ? ['STRING'] : ['TIMESTAMP']);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | '<impala>EXTRACT' '(' AnyCursor RightParenthesisOrError
-   {
-     parser.valueExpressionSuggest();
-     parser.applyTypeToSuggestions(['STRING', 'TIMESTAMP']);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | '<impala>EXTRACT' '(' ValueExpression_EDIT FromOrComma ValueExpression RightParenthesisOrError
-   {
-     parser.applyTypeToSuggestions($4.toLowerCase() === 'from' ? ['STRING'] : ['TIMESTAMP']);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | '<impala>EXTRACT' '(' ValueExpression_EDIT FromOrComma RightParenthesisOrError
-   {
-     parser.applyTypeToSuggestions($4.toLowerCase() === 'from' ? ['STRING'] : ['TIMESTAMP']);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | '<impala>EXTRACT' '(' ValueExpression_EDIT RightParenthesisOrError
-   {
-     parser.applyTypeToSuggestions(['STRING', 'TIMESTAMP']);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | '<impala>EXTRACT' '(' ValueExpression FromOrComma AnyCursor RightParenthesisOrError
-   {
-     parser.valueExpressionSuggest();
-     parser.applyTypeToSuggestions($4.toLowerCase() === 'from' ? ['TIMESTAMP'] : ['STRING']);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | '<impala>EXTRACT' '(' FromOrComma AnyCursor RightParenthesisOrError
-   {
-     parser.valueExpressionSuggest();
-     parser.applyTypeToSuggestions($4.toLowerCase() === 'from' ? ['TIMESTAMP'] : ['STRING']);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | '<impala>EXTRACT' '(' ValueExpression FromOrComma ValueExpression_EDIT RightParenthesisOrError
-   {
-     parser.applyTypeToSuggestions($4.toLowerCase() === 'from' ? ['TIMESTAMP'] : ['STRING']);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | '<impala>EXTRACT' '(' FromOrComma ValueExpression_EDIT RightParenthesisOrError
-   {
-    parser.applyTypeToSuggestions($4.toLowerCase() === 'from' ? ['TIMESTAMP'] : ['STRING']);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | '<impala>EXTRACT' '(' ValueExpression 'CURSOR' ValueExpression RightParenthesisOrError
-   {
-     if ($3.types[0] === 'STRING') {
-       parser.suggestValueExpressionKeywords($3, ['FROM']);
-     } else {
-       parser.suggestValueExpressionKeywords($3);
-     }
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | '<impala>EXTRACT' '(' ValueExpression 'CURSOR' RightParenthesisOrError
-   {
-     if ($3.types[0] === 'STRING') {
-       parser.suggestValueExpressionKeywords($3, ['FROM']);
-     } else {
-       parser.suggestValueExpressionKeywords($3);
-     }
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- ;
-
-FromOrComma
- : 'FROM'
- | ','
- ;
-
-SumFunction
- : 'SUM' '(' OptionalAllOrDistinct ValueExpression ')'  -> { types: parser.findReturnTypes($1) }
- | 'SUM' '(' ')'                                        -> { types: parser.findReturnTypes($1) }
- ;
-
-SumFunction_EDIT
- : 'SUM' '(' OptionalAllOrDistinct AnyCursor RightParenthesisOrError
-   {
-     parser.valueExpressionSuggest();
-     parser.applyArgumentTypesToSuggestions($1, 1);
-     if (!$3) {
-       var keywords = parser.isImpala() ? ['ALL', 'DISTINCT'] : ['DISTINCT'];
-       if (parser.yy.result.suggestKeywords) {
-         keywords = parser.yy.result.suggestKeywords.concat(keywords);
-       }
-       parser.suggestKeywords(keywords);
-     }
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | 'SUM' '(' OptionalAllOrDistinct ValueExpression 'CURSOR' RightParenthesisOrError
-   {
-     parser.suggestValueExpressionKeywords($4);
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- | 'SUM' '(' OptionalAllOrDistinct ValueExpression_EDIT RightParenthesisOrError
-   {
-     if (parser.yy.result.suggestFunctions && ! parser.yy.result.suggestFunctions.types) {
-       parser.applyArgumentTypesToSuggestions($1, 1);
-     }
-     $$ = { types: parser.findReturnTypes($1) };
-   }
- ;
-
-LateralView
- : '<hive>LATERAL' '<hive>VIEW' OptionalOuter UserDefinedFunction RegularOrBacktickedIdentifier LateralViewColumnAliases  -> { lateralView: { udtf: $4, tableAlias: $5, columnAliases: $6 }}
- | '<hive>LATERAL' '<hive>VIEW' OptionalOuter UserDefinedFunction RegularOrBacktickedIdentifier
-   {
-     if ($4.function.toLowerCase() === 'explode') {
-       $$ = { lateralView: { udtf: $4, tableAlias: $5, columnAliases: ['key', 'value'] }, suggestKeywords: ['AS'] };
-     } else if ($4.function.toLowerCase() === 'posexplode') {
-       $$ = { lateralView: { udtf: $4, tableAlias: $5, columnAliases: ['pos', 'val'] }, suggestKeywords: ['AS'] };
-     } else {
-       $$ = { lateralView: { udtf: $4, tableAlias: $5, columnAliases: [] }, suggestKeywords: ['AS'] };
-     }
-   }
- | '<hive>LATERAL' '<hive>VIEW' OptionalOuter UserDefinedFunction LateralViewColumnAliases                                -> { lateralView: { udtf: $4, columnAliases: $5 }}
- ;
-
-LateralView_EDIT
- : '<hive>LATERAL' '<hive>VIEW' OptionalOuter UserDefinedFunction_EDIT
- | '<hive>LATERAL' '<hive>VIEW' OptionalOuter UserDefinedFunction_EDIT RegularOrBacktickedIdentifier
- | '<hive>LATERAL' '<hive>VIEW' OptionalOuter UserDefinedFunction_EDIT RegularOrBacktickedIdentifier LateralViewColumnAliases
- | '<hive>LATERAL' '<hive>VIEW' OptionalOuter UserDefinedFunction RegularOrBacktickedIdentifier LateralViewColumnAliases_EDIT
- | '<hive>LATERAL' '<hive>VIEW' OptionalOuter UserDefinedFunction PartialBacktickedOrCursor
- | '<hive>LATERAL' '<hive>VIEW' OptionalOuter UserDefinedFunction PartialBacktickedOrCursor LateralViewColumnAliases
- | '<hive>LATERAL' '<hive>VIEW' OptionalOuter 'CURSOR'
-   {
-     if (!$3) {
-       parser.suggestKeywords([{ value: 'OUTER', weight: 2 }, { value: 'explode', weight: 1 }, { value: 'posexplode', weight: 1 }]);
-     } else {
-       parser.suggestKeywords(['explode', 'posexplode']);
-     }
-   }
- | '<hive>LATERAL' 'CURSOR'
-   {
-     parser.suggestKeywords(['VIEW']);
-   }
- ;
-
-OptionalOuter
- :
- | 'OUTER'
- ;
-
-LateralViewColumnAliases
- : '<hive>AS' RegularOrBacktickedIdentifier                                    -> [ $2 ]
- | '<hive>AS' RegularOrBacktickedIdentifier ',' RegularOrBacktickedIdentifier  -> [ $2, $4 ]
- ;
-
-LateralViewColumnAliases_EDIT
- : '<hive>AS' PartialBacktickedOrCursor
- | '<hive>AS' RegularOrBacktickedIdentifier ',' PartialBacktickedOrAnyCursor
- ;

+ 3 - 0
desktop/core/src/desktop/static/desktop/js/autocomplete/spec/sqlSpecLocations.js

@@ -754,16 +754,19 @@
             { type: 'function', location: { first_line: 1, last_line: 1, first_column: 16, last_column: 20 }, function: 'round' },
             { type: 'subQuery', location: { first_line: 1, last_line: 1, first_column: 22, last_column: 25 }, identifierChain: [{ subQuery: 'tmp' }]},
             { type: 'column', location: { first_line: 1, last_line: 1, first_column: 26, last_column: 27 }, identifierChain: [{ name: 'r' }], tables: [{ subQuery: 'tmp' }]},
+            { type: 'alias', source: 'column', alias: 'r', location: { first_line: 1, last_line: 1, first_column: 35, last_column: 36 }, parentLocation: { first_line: 1, last_line: 1, first_column: 16, last_column: 31 } },
             { type: 'selectList', missing: false, location: { first_line: 1, last_line: 1, first_column: 51, last_column: 108 }, subquery: true },
             { type: 'database', location: { first_line: 1, last_line: 1, first_column: 51, last_column: 57 }, identifierChain: [{ name: 'tstDb1' }]},
             { type: 'table', location: { first_line: 1, last_line: 1, first_column: 58, last_column: 60 }, identifierChain: [{ name:'tstDb1' }, { name: 'b1' }]},
             { type: 'column', location: { first_line: 1, last_line: 1, first_column: 61, last_column: 64 }, identifierChain: [{ name: 'cat' }], tables: [{ identifierChain: [{ name:'tstDb1' }, {name: 'b1' }] }]},
+            { type: 'alias', source: 'column', alias: 'bc', location: { first_line: 1, last_line: 1, first_column: 68, last_column: 70 }, parentLocation: { first_line: 1, last_line: 1, first_column: 51, last_column: 64 } },
             { type: 'function', location: { first_line: 1, last_line: 1, first_column: 72, last_column: 74 }, function: 'sum' },
             { type: 'database', location: { first_line: 1, last_line: 1, first_column: 76, last_column: 82 }, identifierChain: [{ name: 'tstDb1' }]},
             { type: 'table', location: { first_line: 1, last_line: 1, first_column: 83, last_column: 85 }, identifierChain: [{ name:'tstDb1' }, { name: 'b1' }]},
             { type: 'column', location: { first_line: 1, last_line: 1, first_column: 86, last_column: 91 }, identifierChain: [{ name: 'price' }], tables: [{ identifierChain: [{ name:'tstDb1' }, {name: 'b1' }] }]},
             { type: 'table', location: { first_line: 1, last_line: 1, first_column: 94, last_column: 98 }, identifierChain: [{ name:'tran' }]},
             { type: 'column', location: { first_line: 1, last_line: 1, first_column: 99, last_column: 102 }, identifierChain: [{name: 'qua' }], tables: [{ identifierChain: [{ name:'tran' }] }]},
+            { type: 'alias', source: 'column', alias: 'r', location: { first_line: 1, last_line: 1, first_column: 107, last_column: 108 }, parentLocation: { first_line: 1, last_line: 1, first_column: 72, last_column: 103 } },
             { type: 'database', location: { first_line: 1, last_line: 1, first_column: 114, last_column: 120 }, identifierChain: [{ name: 'tstDb1' }]},
             { type: 'table', location: { first_line: 1, last_line: 1, first_column: 121, last_column: 123 }, identifierChain: [{ name:'tstDb1' },{ name: 'b1' }]},
             { type: 'table', location: { first_line: 1, last_line: 1, first_column: 139, last_column: 143 }, identifierChain: [{ name:'tran' }]},

+ 3 - 3
desktop/core/src/desktop/static/desktop/js/autocomplete/spec/sqlSpecSelect.js

@@ -7164,16 +7164,16 @@
           afterCursor: ' % 2 = 0',
           containsKeywords: ['CASE'],
           expectedResult: {
-            lowerCase: false,
+            suggestColumns: { types: ['NUMBER'], source: 'where', tables: [{ identifierChain: [{ name: 't1' }] }, { identifierChain: [{ name: 't2' }], alias: 'ta2' }, { identifierChain: [{ name: 't3' }]}] },
             suggestFunctions: { types: ['NUMBER'] },
-            suggestColumns: { source: 'where', types: ['NUMBER'], tables: [{ identifierChain: [{ name: 't1' }] }, { identifierChain: [{ name: 't2' }], alias: 'ta2' }, { identifierChain: [{ name: 't3' }]}] },
             suggestIdentifiers: [{ name: 't1.', type: 'table' }, { name: 'ta2.', type: 'alias' }, { name: 't3.', type:'table' }],
+            lowerCase: false,
             locations: [
               { type: 'statement', location: { first_line: 1, last_line: 1, first_column: 1, last_column: 103 } },
               { type: 'selectList', missing: false, location: { first_line: 1, last_line: 1, first_column: 8, last_column: 33 } },
               { type: 'table', location: { first_line: 1, last_line: 1, first_column: 39, last_column: 41}, identifierChain: [{ name: 't1' }] },
               { type: 'table', location: { first_line: 1, last_line: 1, first_column: 43, last_column: 45}, identifierChain: [{ name: 't2' }] },
-              { type: 'alias', source: 'table', alias: 'ta2', location: { first_line: 1, last_line: 1, first_column: 46, last_column: 52 }, identifierChain: [{ name: 't2' }] },
+              { type: 'alias', source: 'table', alias: 'ta2', location: { first_line: 1, last_line: 1, first_column: 49, last_column: 52 }, identifierChain: [{ name: 't2' }] },
               { type: 'whereClause', missing: true, location: { first_line: 1, last_line: 1, first_column: 52, last_column: 52 } },
               { type: 'limitClause', missing: true, location: { first_line: 1, last_line: 1, first_column: 52, last_column: 52 } },
               { type: 'selectList', missing: false, location: { first_line: 1, last_line: 1, first_column: 74, last_column: 80 }, subquery: true },

Failā izmaiņas netiks attēlotas, jo tās ir par lielu
+ 0 - 0
desktop/core/src/desktop/static/desktop/js/autocomplete/sqlAutocompleteParser.js


+ 11 - 1
desktop/core/src/desktop/static/desktop/js/autocomplete/sqlParseSupport.js

@@ -1368,6 +1368,16 @@ var SqlParseSupport = (function () {
       });
     };
 
+    parser.addColumnAliasLocation = function (location, alias, parentLocation) {
+      parser.yy.locations.push({
+        type: 'alias',
+        source: 'column',
+        alias: alias,
+        location: adjustLocationForCursor(location),
+        parentLocation: adjustLocationForCursor(parentLocation)
+      });
+    };
+
     parser.addTableAliasLocation = function (location, alias, identifierChain) {
       parser.yy.locations.push({
         type: 'alias',
@@ -1649,7 +1659,7 @@ var SqlParseSupport = (function () {
     'getSubQuery', 'addTablePrimary', 'suggestFileFormats', 'suggestDdlAndDmlKeywords', 'checkForSelectListKeywords', 'checkForKeywords',
     'suggestKeywords', 'suggestColRefKeywords', 'suggestTablesOrColumns', 'suggestFunctions', 'suggestAggregateFunctions', 'suggestAnalyticFunctions',
     'suggestColumns', 'suggestGroupBys', 'suggestOrderBys', 'suggestFilters', 'suggestKeyValues', 'suggestTables', 'addFunctionLocation',
-    'addStatementLocation', 'firstDefined', 'addClauseLocation', 'addHdfsLocation', 'addDatabaseLocation', 'addTableAliasLocation',
+    'addStatementLocation', 'firstDefined', 'addClauseLocation', 'addHdfsLocation', 'addDatabaseLocation', 'addColumnAliasLocation', 'addTableAliasLocation',
     'addSubqueryAliasLocation', 'addTableLocation', 'addAsteriskLocation', 'addColumnLocation', 'addUnknownLocation', 'suggestDatabases', 'suggestHdfs',
     'suggestValues'];
 

Failā izmaiņas netiks attēlotas, jo tās ir par lielu
+ 0 - 0
desktop/core/src/desktop/static/desktop/js/autocomplete/sqlSyntaxParser.js


+ 2 - 9
tools/jison/hue-jison.sh

@@ -21,16 +21,9 @@ echo "Generating parser..."
 
 pushd ../../desktop/core/src/desktop/static/desktop/js/autocomplete/jison
 
-# For quick version of select and no support for value expressions (i.e. a = b or a IN (1, 2, 3))
-# cat sql_main.jison ../sql_end.jison > sql.jison
-
-# For quick version of select with value expressions
-#cat sql_valueExpression_dev.jison sql_valueExpression.jison ../sql_end.jison > sql.jison
-
-# For quick version of select with create only and no support for value expressions (i.e. a = b or a IN (1, 2, 3))
-# cat sql_main.jison sql_create.jison sql_end.jison > sql.jison
-
 # === Autocomplete parser ===
+# For quick version of just SELECT statements without value expressions
+# cat autocomplete_header.jison sql_main.jison autocomplete_footer.jison > sqlAutocompleteParser.jison
 cat autocomplete_header.jison sql_main.jison sql_valueExpression.jison sql_error.jison sql_alter.jison sql_analyze.jison sql_create.jison sql_drop.jison sql_grant.jison sql_insert.jison sql_load.jison sql_set.jison sql_show.jison sql_update.jison sql_use.jison autocomplete_footer.jison > sqlAutocompleteParser.jison
 
 echo "Creating SQL autocomplete parser..."

Daži faili netika attēloti, jo izmaiņu fails ir pārāk liels