|
|
@@ -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
|
|
|
- ;
|