diff --git a/scripts/antlr4.js b/scripts/antlr4.js index e0b9f88..f4bc40b 100644 --- a/scripts/antlr4.js +++ b/scripts/antlr4.js @@ -8,7 +8,7 @@ const chalk = require('chalk'); const grammarsPath = path.resolve(__dirname, '../src/grammar'); const outputPath = path.resolve(__dirname, '../src/lib'); -const languageEntries = fs.readdirSync(grammarsPath).filter((item) => item !== 'impala'); // impala is not support yet. +const languageEntries = fs.readdirSync(grammarsPath); const baseCmd = 'antlr4ts -visitor -listener -Xexact-output-dir -o'; diff --git a/src/grammar/impala/ImpalaSqlLexer.g4 b/src/grammar/impala/ImpalaSqlLexer.g4 new file mode 100644 index 0000000..4fa5926 --- /dev/null +++ b/src/grammar/impala/ImpalaSqlLexer.g4 @@ -0,0 +1,366 @@ +/* +Apache Impala grammar. +The MIT License (MIT). +Copyright (c) 2023, Michał Lorek. +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +lexer grammar ImpalaSqlLexer; + +options { caseInsensitive = true; } + +KW_ADD : 'ADD'; +KW_ALL : 'ALL'; +KW_ANALYTIC : 'ANALYTIC'; +KW_ALTER : 'ALTER'; +KW_AND : 'AND'; +KW_ANY : 'ANY'; +KW_ANTI : 'ANTI'; +KW_ARRAY : 'ARRAY'; +KW_AS : 'AS'; +KW_ASC : 'ASC'; +KW_AT : 'AT'; +KW_AGGREGATE : 'AGGREGATE'; +KW_AUTHORIZATION : 'AUTHORIZATION'; +KW_BERNOULLI : 'BERNOULLI'; +KW_BETWEEN : 'BETWEEN'; +KW_BLOCK_SIZE : 'BLOCK_SIZE'; +KW_PARTITIONED : 'PARTITIONED'; +KW_PREPARE_FN : 'PREPARE_FN'; +KW_EXTERNAL : 'EXTERNAL'; +KW_CLOSEFN : 'CLOSEFN'; +KW_SORT : 'SORT'; +KW_PURGE : 'PURGE'; +KW_STORED : 'STORED'; +KW_LOCATION : 'LOCATION'; +KW_TBLPROPERTIES : 'TBLPROPERTIES'; +KW_BY : 'BY'; +KW_CASCADE : 'CASCADE'; +KW_CASE : 'CASE'; +KW_CAST : 'CAST'; +KW_CACHED : 'CACHED'; +KW_CHANGE : 'CHANGE'; +KW_COLUMN : 'COLUMN'; +KW_COLUMNS : 'COLUMNS'; +KW_COMMENT : 'COMMENT'; +KW_COMPRESSION : 'COMPRESSION'; +KW_COMPUTE : 'COMPUTE'; +KW_CREATE : 'CREATE'; +KW_CROSS : 'CROSS'; +KW_CURRENT : 'CURRENT'; +KW_CURRENT_DATE : 'CURRENT_DATE'; +KW_CURRENT_PATH : 'CURRENT_PATH'; +KW_CURRENT_TIME : 'CURRENT_TIME'; +KW_CURRENT_TIMESTAMP : 'CURRENT_TIMESTAMP'; +KW_CURRENT_USER : 'CURRENT_USER'; +KW_DATA : 'DATA'; +KW_DATABASE : 'DATABASE'; +KW_DATABASES : 'DATABASES'; +KW_DAY : 'DAY'; +KW_DAYS : 'DAYS'; +KW_DELETE : 'DELETE'; +KW_DEFAULT : 'DEFAULT'; +KW_DELIMITED : 'DELIMITED'; +KW_DISABLE : 'DISABLE'; +KW_UPDATE : 'UPDATE'; +KW_DESC : 'DESC'; +KW_DESCRIBE : 'DESCRIBE'; +KW_DISTINCT : 'DISTINCT'; +KW_DROP : 'DROP'; +KW_ELSE : 'ELSE'; +KW_ENCODING : 'ENCODING'; +KW_END : 'END'; +KW_ESCAPE : 'ESCAPE'; +KW_ESCAPED : 'ESCAPED'; +KW_EXCEPT : 'EXCEPT'; +KW_EXCLUDING : 'EXCLUDING'; +KW_EXISTS : 'EXISTS'; +KW_EXPLAIN : 'EXPLAIN'; +KW_EXTRACT : 'EXTRACT'; +KW_EXTENDED : 'EXTENDED'; +KW_FALSE : 'FALSE'; +KW_FIELDS : 'FIELDS'; +KW_FILEFORMAT : 'FILEFORMAT'; +KW_FILES : 'FILES'; +KW_FILTER : 'FILTER'; +KW_FIRST : 'FIRST'; +KW_FINALIZE_FN : 'FINALIZE_FN'; +KW_FOLLOWING : 'FOLLOWING'; +KW_FOR : 'FOR'; +KW_FORMAT : 'FORMAT'; +KW_FORMATTED : 'FORMATTED'; +KW_FOREIGN : 'FOREIGN'; +KW_FROM : 'FROM'; +KW_FULL : 'FULL'; +KW_FUNCTION : 'FUNCTION'; +KW_FUNCTIONS : 'FUNCTIONS'; +KW_GRANT : 'GRANT'; +KW_GROUP : 'GROUP'; +KW_GROUPING : 'GROUPING'; +KW_HASH : 'HASH'; +KW_HAVING : 'HAVING'; +KW_HOUR : 'HOUR'; +KW_HOURS : 'HOURS'; +KW_IF : 'IF'; +KW_IN : 'IN'; +KW_INCLUDING : 'INCLUDING'; +KW_INCREMENTAL : 'INCREMENTAL'; +KW_INNER : 'INNER'; +KW_INPATH : 'INPATH'; +KW_INSERT : 'INSERT'; +KW_INTERSECT : 'INTERSECT'; +KW_INTERVAL : 'INTERVAL'; +KW_INTERMEDIATE : 'INTERMEDIATE'; +KW_INTO : 'INTO'; +KW_INIT_FN : 'INIT_FN'; +KW_INVALIDATE : 'INVALIDATE'; +KW_IS : 'IS'; +KW_JOIN : 'JOIN'; +KW_KEY : 'KEY'; +KW_KUDU : 'KUDU'; +KW_LAST : 'LAST'; +KW_LATERAL : 'LATERAL'; +KW_LEFT : 'LEFT'; +KW_LIKE : 'LIKE'; +KW_LIMIT : 'LIMIT'; +KW_LINES : 'LINES'; +KW_LOAD : 'LOAD'; +KW_LOCALTIME : 'LOCALTIME'; +KW_LOCALTIMESTAMP : 'LOCALTIMESTAMP'; +KW_METADATA : 'METADATA'; +KW_MAP : 'MAP'; +KW_MINUTE : 'MINUTE'; +KW_MINUTES : 'MINUTES'; +KW_MONTH : 'MONTH'; +KW_MONTHS : 'MONTHS'; +KW_MERGE_FN : 'MERGE_FN'; +KW_NFC : 'NFC'; +KW_NFD : 'NFD'; +KW_NFKC : 'NFKC'; +KW_NFKD : 'NFKD'; +KW_NORMALIZE : 'NORMALIZE'; +KW_NOT : 'NOT'; +KW_NULL : 'NULL'; +KW_NULLS : 'NULLS'; +KW_OFFSET : 'OFFSET'; +KW_ON : 'ON'; +KW_OPTION : 'OPTION'; +KW_OR : 'OR'; +KW_ORDER : 'ORDER'; +KW_ORDINALITY : 'ORDINALITY'; +KW_OUTER : 'OUTER'; +KW_OWNER : 'OWNER'; +KW_OVER : 'OVER'; +KW_OVERWRITE : 'OVERWRITE'; +KW_PARTITION : 'PARTITION'; +KW_PARTITIONS : 'PARTITIONS'; +KW_PARQUET : 'PARQUET'; +KW_POSITION : 'POSITION'; +KW_PRECEDING : 'PRECEDING'; +KW_PRIMARY : 'PRIMARY'; +KW_REPLICATION : 'REPLICATION'; +KW_PRIVILEGES : 'PRIVILEGES'; +KW_PROPERTIES : 'PROPERTIES'; +KW_RANGE : 'RANGE'; +KW_RECOVER : 'RECOVER'; +KW_RENAME : 'RENAME'; +KW_REPEATABLE : 'REPEATABLE'; +KW_REPLACE : 'REPLACE'; +KW_RESTRICT : 'RESTRICT'; +KW_RETURNS : 'RETURNS'; +KW_REVOKE : 'REVOKE'; +KW_REFRESH : 'REFRESH'; +KW_REGEXP : 'REGEXP'; +KW_RLIKE : 'RLIKE'; +KW_RIGHT : 'RIGHT'; +KW_ROLE : 'ROLE'; +KW_ROLES : 'ROLES'; +KW_ROW : 'ROW'; +KW_ROWS : 'ROWS'; +KW_SCHEMA : 'SCHEMA'; +KW_SCHEMAS : 'SCHEMAS'; +KW_SECOND : 'SECOND'; +KW_SECONDS : 'SECONDS'; +KW_SELECT : 'SELECT'; +KW_SERDEPROPERTIES : 'SERDEPROPERTIES'; +KW_SET : 'SET'; +KW_SEMI : 'SEMI'; +KW_SERVER : 'SERVER'; +KW_SHOW : 'SHOW'; +KW_SHUTDOWN : 'SHUTDOWN'; +KW_SOME : 'SOME'; +KW_STATS : 'STATS'; +KW_STRUCT : 'STRUCT'; +KW_STRAIGHT_JOIN : 'STRAIGHT_JOIN'; +KW_SUBSTRING : 'SUBSTRING'; +KW_SYSTEM : 'SYSTEM'; +KW_SYMBOL : 'SYMBOL'; +KW_SERIALIZE_FN : 'SERIALIZE_FN'; +KW_TABLE : 'TABLE'; +KW_TABLES : 'TABLES'; +KW_TABLESAMPLE : 'TABLESAMPLE'; +KW_TERMINATED : 'TERMINATED '; +KW_THEN : 'THEN'; +KW_TO : 'TO'; +KW_TRUE : 'TRUE'; +KW_TRY_CAST : 'TRY_CAST'; +KW_TRUNCATE : 'TRUNCATE'; +KW_UNCACHED : 'UNCACHED'; +KW_UESCAPE : 'UESCAPE'; +KW_UNBOUNDED : 'UNBOUNDED'; +KW_UNION : 'UNION'; +KW_UNNEST : 'UNNEST'; +KW_UNSET : 'UNSET'; +KW_USE : 'USE'; +KW_USER : 'USER'; +KW_USING : 'USING'; +KW_UPDATE_FN : 'UPDATE_FN'; +KW_UPSERT : 'UPSERT'; +KW_URI : 'URI'; +KW_VALUE : 'VALUE'; +KW_VALUES : 'VALUES'; +KW_VIEW : 'VIEW'; +KW_VIEWS : 'VIEWS'; +KW_WHEN : 'WHEN'; +KW_WHERE : 'WHERE'; +KW_WITH : 'WITH'; +KW_YEAR : 'YEAR'; +KW_YEARS : 'YEARS'; +KW_TEXTFILE : 'TEXTFILE'; +KW_ORC : 'ORC'; +KW_AVRO : 'AVRO'; +KW_SEQUENCEFILE : 'SEQUENCEFILE'; +KW_RCFILE : 'RCFILE'; +KW_REFERENCES : 'REFERENCES'; +KW_NOVALIDATE : 'NOVALIDATE'; +KW_RELY : 'RELY'; + +STATS_NUMDVS : '\'NUMDVS\''; +STATS_NUMNULLS : '\'NUMNULLS\''; +STATS_AVGSIZE : '\'AVGSIZE\''; +STATS_MAXSIZE : '\'MAXSIZE\''; + +EQ : '='; +NEQ : '<>' | '!='; +LT : '<'; +LTE : '<='; +GT : '>'; +GTE : '>='; +PLUS: '+'; +MINUS: '-'; +ASTERISK: '*'; +SLASH: '/'; +PERCENT: '%'; +CONCAT: '||'; + +DOT : '.'; +SEMICOLON: ';'; +COMMA: ','; +COLON : ':' ; +LPAREN : '(' ; +RPAREN : ')' ; +LSQUARE : '[' ; +RSQUARE : ']' ; +LCURLY : '{'; +RCURLY : '}'; + +BITWISEOR : '|'; +QUESTION : '?'; + +RIGHT_ARROW : '->'; + +STRING + : '\'' ( ~'\'' | '\'\'' )* '\'' + | '"' ( ~'"' | '""' )* '"' + ; + +UNICODE_STRING + : 'U&\'' ( ~'\'' | '\'\'' )* '\'' + ; + +// Note: we allow any character inside the binary literal and validate +// its a correct literal when the AST is being constructed. This +// allows us to provide more meaningful error messages to the user +BINARY_LITERAL + : 'X\'' (~'\'')* '\'' + ; + +INTEGER_VALUE + : DIGIT+ + ; + +DECIMAL_VALUE + : DIGIT+ '.' DIGIT* + | '.' DIGIT+ + ; + +DOUBLE_VALUE + : DIGIT+ ('.' DIGIT*)? EXPONENT + | '.' DIGIT+ EXPONENT + ; + +IDENTIFIER + : (LETTER | '_') (LETTER | DIGIT | '_' | '@' | ':')* + ; + +DIGIT_IDENTIFIER + : DIGIT (LETTER | DIGIT | '_' | '@' | ':')+ + ; + +QUOTED_IDENTIFIER + : '"' ( ~'"' | '""' )* '"' + ; + +BACKQUOTED_IDENTIFIER + : '`' ( ~'`' | '``' )* '`' + ; + +TIME_WITH_TIME_ZONE + : 'TIME' WS 'WITH' WS 'TIME' WS 'ZONE' + ; + +TIMESTAMP_WITH_TIME_ZONE + : 'TIMESTAMP' WS 'WITH' WS 'TIME' WS 'ZONE' + ; + +DOUBLE_PRECISION + : 'DOUBLE' WS 'PRECISION' + ; + +fragment EXPONENT + : 'E' [+-]? DIGIT+ + ; + +fragment DIGIT + : [0-9] + ; + +fragment LETTER + : [A-Z] + ; + +SIMPLE_COMMENT + : '--' ~[\r\n]* '\r'? '\n'? -> channel(HIDDEN) + ; + +BRACKETED_COMMENT + : '/*' .*? '*/' -> channel(HIDDEN) + ; + +WS + : [ \r\n\t]+ -> channel(HIDDEN) + ; diff --git a/src/grammar/impala/ImpalaSqlParser.g4 b/src/grammar/impala/ImpalaSqlParser.g4 new file mode 100644 index 0000000..7d6e660 --- /dev/null +++ b/src/grammar/impala/ImpalaSqlParser.g4 @@ -0,0 +1,946 @@ +/* + * Licensed 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. + */ + +parser grammar ImpalaSqlParser; + +options +{ + tokenVocab=ImpalaSqlLexer; +} + +program : (statement SEMICOLON?)* EOF; + +statement + : queryStatement + | useStatement + | createStatement + | alterStatement + | truncateTableStatement + | describeStatement + | computeStatement + | dropStatement + | grantStatement + | revokeStatement + | insertStatement + | deleteStatement + | updateStatement + | upsertStatement + | showStatement + | addCommentStatement + | explainStatement + | setStatement + | shutdownStatement + | invalidateMetaStatement + | loadDataStatement + | refreshStatement + ; + +useStatement: KW_USE databaseNamePath; + +createStatement + : createSchema + | createRole + | createAggregateFunction + | createFunction + | createView + | createKuduTableAsSelect + | createTableLike + | createTableSelect + ; + +createTableSelect + : KW_CREATE KW_EXTERNAL? KW_TABLE ifNotExists? tableNameCreate + (LPAREN columnDefinition (COMMA columnDefinition)* (COMMA constraintSpecification)? RPAREN)? + (KW_PARTITIONED KW_BY (partitionedBy | createColumnAliases) )? + createCommonItem + (KW_AS queryStatement)? + ; + +createTableLike + : KW_CREATE KW_EXTERNAL? KW_TABLE ifNotExists? tableNameCreate + KW_LIKE (tableNamePath | KW_PARQUET parquet=stringLiteral) + (KW_PARTITIONED KW_BY partitionedBy)? + createCommonItem + ; + +createKuduTableAsSelect + : KW_CREATE KW_EXTERNAL? KW_TABLE ifNotExists? tableNameCreate + (LPAREN kuduTableElement (COMMA kuduTableElement)* (COMMA KW_PRIMARY KW_KEY columnAliases)? RPAREN)? + (KW_PRIMARY KW_KEY columnAliases?)? + (KW_PARTITION KW_BY kuduPartitionClause)? + (KW_COMMENT stringLiteral)? + KW_STORED KW_AS KW_KUDU + (KW_TBLPROPERTIES tblProp=properties)? + (KW_AS queryStatement)? + ; + +createView: KW_CREATE KW_VIEW ifNotExists? viewNameCreate viewColumns? (KW_COMMENT stringLiteral)? (KW_TBLPROPERTIES tblProp=properties)? KW_AS queryStatement; + +createSchema: + KW_CREATE (KW_SCHEMA | KW_DATABASE) ifNotExists? databaseNameCreate + (KW_COMMENT comment=stringLiteral)? (KW_LOCATION location=stringLiteral)? + ; + +createRole: KW_CREATE KW_ROLE name=identifier; + +createAggregateFunction + : KW_CREATE KW_AGGREGATE? KW_FUNCTION ifNotExists? functionNameCreate (LPAREN(type (COMMA type)*)? RPAREN)? + KW_RETURNS type + (KW_INTERMEDIATE type)? + KW_LOCATION STRING + (KW_INIT_FN EQ STRING)? + KW_UPDATE_FN EQ STRING + KW_MERGE_FN EQ STRING + (KW_PREPARE_FN EQ STRING)? + (KW_CLOSEFN EQ STRING)? + (KW_SERIALIZE_FN EQ STRING)? + (KW_FINALIZE_FN EQ STRING)? + ; + +createFunction + : KW_CREATE KW_FUNCTION ifNotExists? functionNameCreate (LPAREN(type (COMMA type)*)? RPAREN)? + (KW_RETURNS type)? + KW_LOCATION STRING + KW_SYMBOL EQ symbol=stringLiteral + ; + +alterStatement + : alterDatabase + | alterUnSetOrSetViewTblproperties + | renameTable + | alterViewOwner + | alterView + | renameView + | dropPartitionByRangeOrValue + | alterFormat + | recoverPartitions + | addPartitionByRangeOrValue + | alterTableNonKuduOrKuduOnly + | addSingleColumn + | replaceOrAddColumns + | changeColumnDefine + | alterStatsKey + | alterPartitionCache + | alterDropSingleColumn + | alterTableOwner + ; + +alterDatabase: KW_ALTER KW_DATABASE databaseNamePath KW_SET KW_OWNER (KW_USER | KW_ROLE) identifier; + +alterStatsKey: KW_ALTER KW_TABLE tableNamePath KW_SET KW_COLUMN KW_STATS columnNamePath LPAREN statsKey EQ stringLiteral (COMMA statsKey EQ stringLiteral)? RPAREN; + +alterPartitionCache: KW_ALTER KW_TABLE tableNamePath (KW_PARTITION expression)? KW_SET ((KW_CACHED KW_IN stringLiteral (KW_WITH KW_REPLICATION EQ number)?) | KW_UNCACHED); + +changeColumnDefine: KW_ALTER KW_TABLE tableNamePath KW_CHANGE KW_COLUMN columnSpecWithKudu; + +alterDropSingleColumn: KW_ALTER KW_TABLE tableNamePath KW_DROP (KW_COLUMN)? columnNamePath; + +alterTableOwner: KW_ALTER KW_TABLE tableNamePath KW_SET KW_OWNER (KW_USER | KW_ROLE) identifier; + +replaceOrAddColumns: KW_ALTER KW_TABLE tableNamePath (KW_REPLACE | KW_ADD ifNotExists?) KW_COLUMNS LPAREN columnSpecWithKudu (COMMA columnSpecWithKudu)*? RPAREN; + +addSingleColumn: KW_ALTER KW_TABLE tableNamePath KW_ADD KW_COLUMN ifNotExists? createColumnSpecWithKudu; + +alterTableNonKuduOrKuduOnly: KW_ALTER KW_TABLE tableNamePath KW_ALTER (KW_COLUMN)? columnNamePath (KW_SET (kuduStorageAttr | KW_COMMENT stringLiteral ) | KW_DROP KW_DEFAULT); + +addPartitionByRangeOrValue: KW_ALTER KW_TABLE tableNamePath KW_ADD ifNotExists? (KW_PARTITION expression (KW_LOCATION stringLiteral)? (cacheSpec)? | KW_RANGE KW_PARTITION kuduPartitionSpec); + +alterFormat: KW_ALTER KW_TABLE tableNamePath (KW_PARTITION expression)? KW_SET ((KW_FILEFORMAT fileFormat) | (KW_ROW KW_FORMAT rowFormat) | (KW_LOCATION stringLiteral) | (KW_TBLPROPERTIES tblProp=properties) | (KW_SERDEPROPERTIES tblProp=properties)); + +recoverPartitions: KW_ALTER KW_TABLE tableNamePath KW_RECOVER KW_PARTITIONS; + +dropPartitionByRangeOrValue: KW_ALTER KW_TABLE tableNamePath KW_DROP ifExists? (KW_PARTITION expression KW_PURGE? | KW_RANGE KW_PARTITION kuduPartitionSpec); + +alterView: KW_ALTER KW_VIEW viewNamePath viewColumns? KW_AS queryStatement; + +renameView: KW_ALTER KW_VIEW viewNamePath KW_RENAME KW_TO viewNamePath; + +alterViewOwner: KW_ALTER KW_VIEW viewNamePath KW_SET KW_OWNER (KW_USER | KW_ROLE) qualifiedName; + +renameTable: KW_ALTER KW_TABLE tableNamePath KW_RENAME KW_TO tableNamePath; + +alterUnSetOrSetViewTblproperties: KW_ALTER KW_VIEW viewNamePath (KW_UNSET | KW_SET) KW_TBLPROPERTIES tblProp=properties; + +truncateTableStatement: KW_TRUNCATE KW_TABLE? ifExists? tableNamePath; + +describeStatement: KW_DESCRIBE KW_DATABASE? (KW_FORMATTED | KW_EXTENDED)? qualifiedName; + +computeStatement + : computeStats + | computeIncrementalStats + ; + +computeStats: KW_COMPUTE KW_STATS tableNamePath (columnAliases)? (KW_TABLESAMPLE KW_SYSTEM LPAREN number RPAREN (KW_REPEATABLE LPAREN number RPAREN)?)?; + +computeIncrementalStats: KW_COMPUTE KW_INCREMENTAL KW_STATS tableNamePath (KW_PARTITION expression)?; + +dropStatement + : dropRole + | dropFunction + | dropIncrementalStats + | dropView + | dropTable + | dropSchema + ; + +dropSchema: KW_DROP (KW_SCHEMA | KW_DATABASE) (ifExists)? databaseNamePath (KW_CASCADE | KW_RESTRICT)?; + +dropView: KW_DROP KW_VIEW ifExists? viewNamePath; + +dropTable: KW_DROP KW_TABLE ifExists? tableNamePath KW_PURGE?; + +dropIncrementalStats: KW_DROP KW_INCREMENTAL? KW_STATS tableNamePath (KW_PARTITION expression)?; + +dropFunction: KW_DROP KW_AGGREGATE? KW_FUNCTION ifExists? functionNamePath (LPAREN(type (COMMA type)*)? RPAREN)?; + +dropRole: KW_DROP KW_ROLE name=identifier; + +grantStatement + : grantRole + | grant + ; + +grantRole: KW_GRANT KW_ROLE identifier KW_TO KW_GROUP identifier; + +grant: KW_GRANT privilege KW_ON objectType (qualifiedName)? KW_TO grantee=principal; + +revokeStatement + : revokeRole + | revoke + ; + +revokeRole: KW_REVOKE KW_ROLE identifier KW_FROM KW_GROUP identifier; + +revoke: KW_REVOKE (KW_GRANT KW_OPTION KW_FOR)? privilege KW_ON objectType (qualifiedName)? KW_FROM (grantee=principal | (KW_ROLE)? identifier); + +insertStatement + : with? KW_INSERT (KW_INTO | KW_OVERWRITE) KW_TABLE? tableNamePath + columnAliases? + (KW_PARTITION LPAREN expression(COMMA expression)*RPAREN)? + queryStatement + ; + +deleteStatement + : delete + | deleteTableRef + ; + +delete: KW_DELETE KW_FROM? tableNamePath (KW_WHERE booleanExpression)?; + +deleteTableRef: KW_DELETE tableNamePath (KW_AS? identifier)? KW_FROM (relation (COMMA relation)*)? (KW_WHERE booleanExpression)?; + +updateStatement: KW_UPDATE tableNamePath KW_SET assignmentList (KW_FROM relation (COMMA relation)*)? (KW_WHERE booleanExpression)?; + +upsertStatement: KW_UPSERT KW_INTO KW_TABLE? tableNamePath columnAliases? queryStatement; + +showStatement + : showRoles + | showRoleGrant + | showGrants + | showFiles + | showPartitions + | showColumnStats + | showTableStats + | showCreateView + | showCreateTable + | showFunctions + | showTables + | showSchemas + ; + +showSchemas + : KW_SHOW (KW_SCHEMAS | KW_DATABASES) + (KW_LIKE? pattern=stringLiteral (BITWISEOR stringLiteral)*)? + ; + +showTables + : + KW_SHOW KW_TABLES (KW_IN tableNamePath)? + (KW_LIKE? pattern=stringLiteral (BITWISEOR stringLiteral)*)? + ; + +showFunctions + : + KW_SHOW (KW_AGGREGATE | KW_ANALYTIC)? KW_FUNCTIONS (KW_IN databaseNamePath)? + (KW_LIKE? pattern=stringLiteral (BITWISEOR stringLiteral)*)? + ; + +showCreateTable: KW_SHOW KW_CREATE KW_TABLE tableNamePath; + +showCreateView: KW_SHOW KW_CREATE KW_VIEW viewNamePath; + +showTableStats: KW_SHOW KW_TABLE KW_STATS tableNamePath; + +showColumnStats: KW_SHOW KW_COLUMN KW_STATS tableNamePath; + +showPartitions: KW_SHOW (KW_RANGE)? KW_PARTITIONS tableNamePath; + +showFiles: KW_SHOW KW_FILES KW_IN tableNamePath (KW_PARTITION LPAREN expression (COMMA expression)?RPAREN)?; + +showRoles: KW_SHOW (KW_CURRENT)? KW_ROLES; + +showRoleGrant: KW_SHOW KW_ROLE KW_GRANT KW_GROUP identifier; + +showGrants + : showDatabaseGrant + | showTableGrant + | showColumnGrant + | KW_SHOW KW_GRANT (KW_USER | KW_ROLE | KW_GROUP) identifier + (KW_ON (KW_SERVER | KW_URI) (qualifiedName)?)? + ; + +showDatabaseGrant: + KW_SHOW KW_GRANT (KW_USER | KW_ROLE | KW_GROUP) identifier + (KW_ON KW_DATABASE (databaseNamePath)?)? + ; + +showTableGrant: + KW_SHOW KW_GRANT (KW_USER | KW_ROLE | KW_GROUP) identifier + (KW_ON KW_TABLE (tableNamePath)?)? + ; + +showColumnGrant: + KW_SHOW KW_GRANT (KW_USER | KW_ROLE | KW_GROUP) identifier + (KW_ON KW_COLUMN (columnNamePath)?)? + ; + +addCommentStatement + : addDatabaseComments + | addTableComments + | addColumnComments + ; + +addDatabaseComments: KW_COMMENT KW_ON KW_DATABASE databaseNamePath KW_IS (stringLiteral | KW_NULL); + +addTableComments: KW_COMMENT KW_ON KW_TABLE tableNamePath KW_IS (stringLiteral | KW_NULL); + +addColumnComments: KW_COMMENT KW_ON KW_COLUMN columnNamePath KW_IS (stringLiteral | KW_NULL); + +explainStatement: KW_EXPLAIN statement; + +setStatement: KW_SET (KW_ALL | identifier EQ expression)?; + +shutdownStatement: COLON KW_SHUTDOWN LPAREN (stringLiteral? | stringLiteral (COMMA expression)? | expression) RPAREN; + +invalidateMetaStatement: KW_INVALIDATE KW_METADATA tableNamePath; + +loadDataStatement: + KW_LOAD KW_DATA KW_INPATH STRING (KW_OVERWRITE)? KW_INTO KW_TABLE tableNamePath + (KW_PARTITION LPAREN expression (COMMA expression)?RPAREN)? + ; + +refreshStatement: refreshMeta | refreshAuth | refreshFunction; + +refreshMeta: KW_REFRESH tableNamePath (KW_PARTITION LPAREN expression (COMMA expression)*? RPAREN)?; + +refreshAuth: KW_REFRESH KW_AUTHORIZATION; + +refreshFunction: KW_REFRESH KW_FUNCTIONS functionNamePath; + +ifExists + : KW_IF KW_EXISTS + ; + +ifNotExists + : KW_IF KW_NOT KW_EXISTS + ; + +tableNameCreate: qualifiedName; + +databaseNameCreate: qualifiedName; + +viewNameCreate: qualifiedName; + +functionNameCreate: qualifiedName; + +columnNamePathCreate: qualifiedName; + +databaseNamePath: qualifiedName; + +tableNamePath: identifier (DOT identifier)*; + +viewNamePath: identifier (DOT identifier)*; + +functionNamePath: qualifiedName; + +columnNamePath: qualifiedName; + +tableOrViewPath: tableNamePath | viewNamePath; + +createCommonItem + : + (KW_SORT KW_BY columnAliases)? + (KW_COMMENT comment=stringLiteral)? + (KW_ROW KW_FORMAT rowFormat)? + (KW_WITH KW_SERDEPROPERTIES serdProp=properties)? + (KW_STORED KW_AS fileFormat)? + (KW_LOCATION location=stringLiteral)? + (KW_CACHED KW_IN cacheName=qualifiedName (KW_WITH KW_REPLICATION EQ INTEGER_VALUE )? | KW_UNCACHED)? + (KW_TBLPROPERTIES tblProp=properties)? + ; + +assignmentList + : assignmentItem (COMMA assignmentItem)* + ; + +assignmentItem + : qualifiedName EQ expression + ; + +viewColumns + : LPAREN columnNamePath (KW_COMMENT stringLiteral)? (COMMA identifier (KW_COMMENT stringLiteral)?)* RPAREN + ; + +queryStatement + : with? queryNoWith + ; + +with + : KW_WITH namedQuery (COMMA namedQuery)* + ; + +constraintSpecification + : + KW_PRIMARY KW_KEY columnAliases (KW_DISABLE)? (KW_NOVALIDATE | COMMA KW_NOVALIDATE)? (KW_RELY | COMMA KW_RELY)? ((COMMA foreignKeySpecification | foreignKeySpecification) (COMMA foreignKeySpecification)*?)? + ; + +foreignKeySpecification + : + KW_FOREIGN KW_KEY columnAliases KW_REFERENCES tableNamePath columnAliases (KW_DISABLE)? (KW_NOVALIDATE)? (KW_RELY)? + ; + +columnDefinition + : columnNamePathCreate type (KW_COMMENT stringLiteral)? + ; + +kuduTableElement + : kuduColumnDefinition + ; + +kuduColumnDefinition + : columnNamePathCreate type (kuduAttributes kuduAttributes*?)? (KW_COMMENT stringLiteral)? (KW_PRIMARY KW_KEY )? + ; + +columnSpecWithKudu + : columnNamePath type (KW_COMMENT stringLiteral)? (kuduAttributes kuduAttributes*?)? + ; + +createColumnSpecWithKudu + : columnNamePathCreate type (KW_COMMENT stringLiteral)? (kuduAttributes kuduAttributes*?)? + ; + +kuduAttributes + : ((KW_NOT)? KW_NULL | kuduStorageAttr) + ; + +kuduStorageAttr + : KW_ENCODING expression + | KW_COMPRESSION expression + | KW_DEFAULT expression + | KW_BLOCK_SIZE number + ; + +statsKey + : STATS_NUMDVS + | STATS_NUMNULLS + | STATS_AVGSIZE + | STATS_MAXSIZE + ; + +fileFormat + : KW_TEXTFILE + | KW_PARQUET + | KW_ORC + | KW_AVRO + | KW_SEQUENCEFILE + | KW_RCFILE + ; + +kuduPartitionClause + : (hashClause (COMMA hashClause)*? (COMMA rangeClause)?) | rangeClause + ; + +hashClause + : KW_HASH columnAliases? KW_PARTITIONS number + ; + +rangeClause + : KW_RANGE columnAliases? LPAREN (KW_PARTITION kuduPartitionSpec (COMMA KW_PARTITION kuduPartitionSpec)*?) RPAREN + ; + +kuduPartitionSpec + : KW_VALUE partitionCol expression | (expression rangeOperator)? KW_VALUES (rangeOperator expression)? + ; + +cacheSpec + : KW_CACHED KW_IN identifier (KW_WITH KW_REPLICATION EQ number)? + | KW_UNCACHED + ; + +rangeOperator + : + | LT + | LTE + | GT + | GTE + ; + +partitionCol + : EQ + | NEQ + | KW_LIKE + | KW_RLIKE + | KW_REGEXP + | KW_BETWEEN + | KW_IN + | rangeOperator + ; + +likeClause + : KW_LIKE qualifiedName (optionType=(KW_INCLUDING | KW_EXCLUDING) KW_PROPERTIES)? + ; + +properties + : LPAREN property (COMMA property)* RPAREN + ; + +partitionedBy + : LPAREN columnDefinition (COMMA columnDefinition)*? RPAREN + ; + +sortedBy + : expression (COMMA expression)* + ; + +rowFormat + : KW_DELIMITED (KW_FIELDS KW_TERMINATED KW_BY stringLiteral (KW_ESCAPED KW_BY stringLiteral)?)? (KW_LINES KW_TERMINATED KW_BY stringLiteral)? + ; + +property + : identifier (EQ expression)? + ; + +queryNoWith: + queryTerm + (KW_ORDER KW_BY sortItem (COMMA sortItem)*)? + (KW_LIMIT rows=expression (KW_OFFSET offset=INTEGER_VALUE )?)? + ; + +queryTerm + : queryPrimary #queryTermDefault + | left=queryTerm operator=KW_INTERSECT setQuantifier? right=queryTerm #setOperation + | left=queryTerm operator=(KW_UNION | KW_EXCEPT) setQuantifier? right=queryTerm #setOperation + ; + +queryPrimary + : querySpecification #queryPrimaryDefault + | KW_TABLE tableNamePath #table + | KW_VALUES expression (COMMA expression)* #inlineTable + | LPAREN queryNoWith RPAREN #subquery + ; + +sortItem + : columnItem ordering=(KW_ASC | KW_DESC)? (KW_NULLS nullOrdering=(KW_FIRST | KW_LAST))? + ; + +querySpecification + : KW_SELECT setQuantifier? (KW_STRAIGHT_JOIN)? selectItem (COMMA selectItem)* + (KW_FROM relation (COMMA relation)*)? + (KW_WHERE where=booleanExpression)? + (KW_GROUP KW_BY groupBy)? + (KW_HAVING having=booleanExpression)? + ; + +groupBy + : setQuantifier? groupingElement (COMMA groupingElement)* + ; + +groupingElement + : groupingSet #singleGroupingSet + ; + +groupingSet + : LPAREN (columnItem (COMMA columnItem)*)? RPAREN + | columnItem + ; + +namedQuery + : name=identifier (columnAliases)? KW_AS subQueryRelation + ; + +setQuantifier + : KW_DISTINCT + | KW_ALL + ; + +selectItem + : columnItem (KW_AS? identifier)? #selectSingle + | qualifiedName DOT ASTERISK #selectAll + | ASTERISK #selectAll + ; + +relation + : left=relation + ( KW_CROSS KW_JOIN right=sampledRelation + | joinType KW_JOIN rightRelation=relation joinCriteria + ) #joinRelation + | sampledRelation #relationDefault + ; + +joinType + : KW_INNER? + | KW_LEFT KW_INNER? + | KW_RIGHT KW_INNER? + | KW_LEFT KW_OUTER? + | KW_RIGHT KW_OUTER? + | KW_FULL KW_OUTER? + | KW_LEFT KW_SEMI + | KW_RIGHT KW_SEMI + | KW_LEFT KW_ANTI + | KW_RIGHT KW_ANTI + ; + +joinCriteria + : KW_ON booleanExpression + | KW_USING LPAREN identifier (COMMA identifier)* RPAREN + ; + +sampledRelation + : aliasedRelation ( + KW_TABLESAMPLE sampleType LPAREN percentage=expression RPAREN (KW_REPEATABLE LPAREN seed=expression RPAREN)? + )? + ; + +sampleType + : KW_BERNOULLI + | KW_SYSTEM + ; + +aliasedRelation + : relationPrimary (KW_AS? identifier columnAliases?)? + ; + +columnAliases + : LPAREN columnNamePath (COMMA columnNamePath)* RPAREN + ; + +createColumnAliases + : LPAREN columnNamePathCreate (COMMA columnNamePathCreate)* RPAREN + ; + +relationPrimary + : tableOrViewPath + | KW_LATERAL? subQueryRelation + | unnest + | parenthesizedRelation + ; + +subQueryRelation: LPAREN queryStatement RPAREN; + +unnest: KW_UNNEST LPAREN expression (COMMA expression)* RPAREN (KW_WITH KW_ORDINALITY)?; + +parenthesizedRelation: LPAREN relation RPAREN; + +columnItem: columnNamePath | expression; + +expression + : booleanExpression + ; + +booleanExpression + : valueExpression predicate[$valueExpression.ctx]? #predicated + | KW_NOT booleanExpression #logicalNot + | left=booleanExpression operator=KW_AND right=booleanExpression #logicalBinary + | left=booleanExpression operator=KW_OR right=booleanExpression #logicalBinary + ; + +predicate[ParserRuleContext value] + : comparisonOperator right=valueExpression #comparison + | comparisonOperator comparisonQuantifier subQueryRelation #quantifiedComparison + | KW_NOT? KW_BETWEEN lower=valueExpression KW_AND upper=valueExpression #between + | KW_NOT? KW_IN LPAREN expression (COMMA expression)* RPAREN #inList + | KW_NOT? KW_IN subQueryRelation #inSubquery + | KW_NOT? KW_LIKE pattern=valueExpression (KW_ESCAPE escape=valueExpression)? #like + | KW_REGEXP pattern=valueExpression #REGEXP + | KW_IS KW_NOT? KW_NULL #nullPredicate + | KW_IS KW_NOT? KW_DISTINCT KW_FROM right=valueExpression #distinctFrom + ; + +valueExpression + : primaryExpression #valueExpressionDefault + | operator=(MINUS | PLUS) valueExpression #arithmeticUnary + | left=valueExpression operator=(ASTERISK | SLASH | PERCENT) right=valueExpression #arithmeticBinary + | left=valueExpression operator=(PLUS | MINUS) right=valueExpression #arithmeticBinary + | left=valueExpression CONCAT right=valueExpression #concatenation + ; + +primaryExpression + : KW_NULL #nullLiteral + | interval #intervalLiteral + | identifier stringLiteral #typeConstructor + | DOUBLE_PRECISION stringLiteral #typeConstructor + | number #numericLiteral + | booleanValue #booleanLiteral + | stringLiteral #stringLiteralValues + | BINARY_LITERAL #binaryLiteral + | QUESTION #parameter + | KW_POSITION LPAREN valueExpression KW_IN valueExpression RPAREN #position + | LPAREN expression (KW_AS type)? (COMMA expression (KW_AS type)?)*? RPAREN #rowConstructor + | KW_ROW LPAREN expression (COMMA expression)* RPAREN #rowConstructor + | functionNamePath LPAREN ASTERISK RPAREN filter? over? #functionCall + | functionNamePath LPAREN (setQuantifier? expression (COMMA expression)*)? + (KW_ORDER KW_BY sortItem (COMMA sortItem)*)? RPAREN filter? over? #functionCall + | identifier RIGHT_ARROW expression #lambda + | LPAREN (identifier (COMMA identifier)*)? RPAREN RIGHT_ARROW expression #lambda + | LPAREN queryStatement RPAREN #subqueryExpression + | KW_EXISTS LPAREN queryStatement RPAREN #exists + | KW_CASE valueExpression whenClause+ (KW_ELSE elseExpression=expression)? KW_END #simpleCase + | KW_CASE whenClause+ (KW_ELSE elseExpression=expression)? KW_END #searchedCase + | KW_CAST LPAREN expression KW_AS type RPAREN #cast + | KW_TRY_CAST LPAREN expression KW_AS type RPAREN #cast + | KW_ARRAY LSQUARE (expression (COMMA expression)*)? RSQUARE #arrayConstructor + | value=primaryExpression LSQUARE index=valueExpression RSQUARE #subscript + | identifier #columnReference + | base=primaryExpression DOT fieldName=identifier #dereference + | name=KW_CURRENT_DATE #specialDateTimeFunction + | name=KW_CURRENT_TIME (LPAREN precision=INTEGER_VALUE RPAREN)? #specialDateTimeFunction + | name=KW_CURRENT_TIMESTAMP (LPAREN precision=INTEGER_VALUE RPAREN)? #specialDateTimeFunction + | name=KW_LOCALTIME (LPAREN precision=INTEGER_VALUE RPAREN)? #specialDateTimeFunction + | name=KW_LOCALTIMESTAMP (LPAREN precision=INTEGER_VALUE RPAREN)? #specialDateTimeFunction + | name=KW_CURRENT_USER #currentUser + | name=KW_CURRENT_PATH #currentPath + | KW_SUBSTRING LPAREN valueExpression KW_FROM valueExpression (KW_FOR valueExpression)? RPAREN #substring + | KW_NORMALIZE LPAREN valueExpression (COMMA normalForm)? RPAREN #normalize + | KW_EXTRACT LPAREN identifier KW_FROM valueExpression RPAREN #extract + | LPAREN expression RPAREN #parenthesizedExpression + | KW_GROUPING LPAREN (qualifiedName (COMMA qualifiedName)*)? RPAREN #groupingOperation + ; + +stringLiteral + : STRING #basicStringLiteral + | UNICODE_STRING (KW_UESCAPE STRING)? #unicodeStringLiteral + ; + +comparisonOperator + : EQ | NEQ | LT | LTE | GT | GTE + ; + +comparisonQuantifier + : KW_ALL | KW_SOME | KW_ANY + ; + +booleanValue + : KW_TRUE | KW_FALSE + ; + +interval + : INTEGER_VALUE intervalField + | LPAREN INTEGER_VALUE RPAREN intervalField + | KW_INTERVAL INTEGER_VALUE intervalField + | KW_INTERVAL LPAREN INTEGER_VALUE RPAREN intervalField + ; + +intervalField + : KW_YEAR | KW_YEARS | KW_MONTH | KW_MONTHS | KW_DAY | KW_DAYS | KW_HOUR | KW_HOURS | KW_MINUTE | KW_MINUTES | KW_SECOND | KW_SECONDS + ; + +normalForm + : KW_NFD | KW_NFC | KW_NFKD | KW_NFKC + ; + +type + : type KW_ARRAY + | KW_ARRAY LT type GT + | KW_MAP LT type COMMA type GT + | KW_STRUCT LT identifier COLON type (COMMA identifier COLON type)* GT + | baseType (LPAREN typeParameter (COMMA typeParameter)* RPAREN)? + ; + +typeParameter + : INTEGER_VALUE | type + ; + +baseType + : TIME_WITH_TIME_ZONE + | TIMESTAMP_WITH_TIME_ZONE + | DOUBLE_PRECISION + | identifier + ; + +whenClause + : KW_WHEN condition=expression KW_THEN result=expression + ; + +filter + : KW_FILTER LPAREN KW_WHERE booleanExpression RPAREN + ; + +over + : KW_OVER LPAREN + (KW_PARTITION KW_BY partition+=expression (COMMA partition+=expression)*)? + (KW_ORDER KW_BY sortItem (COMMA sortItem)*)? + windowFrame? + RPAREN + ; + +/** +* replace start identifier with start_ in grammar. +* https://github.com/tunnelvisionlabs/antlr4ts/issues/417 +*/ +windowFrame + : frameType=KW_RANGE start_=frameBound + | frameType=KW_ROWS start_=frameBound + | frameType=KW_RANGE KW_BETWEEN start_=frameBound KW_AND end=frameBound + | frameType=KW_ROWS KW_BETWEEN start_=frameBound KW_AND end=frameBound + ; + +frameBound + : KW_UNBOUNDED boundType=KW_PRECEDING #unboundedFrame + | KW_UNBOUNDED boundType=KW_FOLLOWING #unboundedFrame + | KW_CURRENT KW_ROW #currentRowBound + | expression boundType=(KW_PRECEDING | KW_FOLLOWING) #boundedFrame + ; + +pathElement + : identifier DOT identifier #qualifiedArgument + | identifier #unqualifiedArgument + ; + +pathSpecification + : pathElement (COMMA pathElement)* + ; + +privilege + : KW_ALL | KW_ALTER | KW_DROP | KW_CREATE | KW_INSERT | KW_REFRESH | KW_SELECT (LPAREN columnName=identifier RPAREN)? + ; +objectType + : KW_SERVER | KW_URI | KW_DATABASE | KW_TABLE + ; +qualifiedName + : identifier (DOT identifier)* + ; + +principal + : KW_ROLE identifier #rolePrincipal + | KW_USER identifier #userPrincipal + | KW_GROUP identifier #groupPrincipal + ; + +identifier + : IDENTIFIER #unquotedIdentifier + | STRING #quotedIdentifier + | nonReserved #unquotedIdentifier + | BACKQUOTED_IDENTIFIER #backQuotedIdentifier + | DIGIT_IDENTIFIER #digitIdentifier + ; + +number + : MINUS? DECIMAL_VALUE #decimalLiteral + | MINUS? DOUBLE_VALUE #doubleLiteral + | MINUS? INTEGER_VALUE #integerLiteral + ; + + +nonReserved +// IMPORTANT: this rule must only contain tokens. Nested rules are not supported. See SqlParser.exitNonReserved + : KW_ADD + | KW_ALL + | KW_ANY + | KW_ARRAY + | KW_ASC + | KW_AT + | KW_BERNOULLI + | KW_CASCADE + | KW_COLUMN + | KW_COLUMNS + | KW_COMMENT + | KW_CURRENT + | KW_DATA + | KW_DATABASE + | KW_DATABASES + | KW_DAY + | KW_DAYS + | KW_DESC + | KW_EXCLUDING + | KW_EXPLAIN + | KW_FILTER + | KW_FIRST + | KW_FOLLOWING + | KW_FORMAT + | KW_FUNCTIONS + | KW_GRANT + | KW_HOUR + | KW_IF + | KW_INCLUDING + | KW_INTERVAL + | KW_LAST + | KW_LATERAL + | KW_LIMIT + | KW_MAP + | KW_MINUTE + | KW_MONTH + | KW_NFC + | KW_NFD + | KW_NFKC + | KW_NFKD + | KW_NULLS + | KW_OFFSET + | KW_OPTION + | KW_ORDINALITY + | KW_OVER + | KW_PARTITION + | KW_PARTITIONS + | KW_PARQUET + | KW_POSITION + | KW_PRECEDING + | KW_PRIVILEGES + | KW_PROPERTIES + | KW_RANGE + | KW_RENAME + | KW_REPEATABLE + | KW_REPLACE + | KW_RESTRICT + | KW_REVOKE + | KW_ROLE + | KW_ROLES + | KW_ROW + | KW_ROWS + | KW_SCHEMA + | KW_SCHEMAS + | KW_SECOND + | KW_SECONDS + | KW_SET + | KW_SHOW + | KW_SOME + | KW_STATS + | KW_SUBSTRING + | KW_SYSTEM + | KW_TABLES + | KW_TABLESAMPLE + | KW_TRUNCATE + | KW_TO + | KW_TRY_CAST + | KW_UNBOUNDED + | KW_USE + | KW_USER + | KW_VIEW + | KW_VIEWS + | KW_YEAR + | KW_DEFAULT + | KW_TEXTFILE + | KW_ORC + | KW_AVRO + | KW_SEQUENCEFILE + | KW_RCFILE + ; \ No newline at end of file diff --git a/src/grammar/impala/README.md b/src/grammar/impala/README.md deleted file mode 100644 index 49ff437..0000000 --- a/src/grammar/impala/README.md +++ /dev/null @@ -1,3 +0,0 @@ -# Impala SQL Grammar - -SQL-like HiveQL, [Hive Grammar](https://github.com/apache/hive/tree/master/hplsql/src/main/antlr4/org/apache/hive/hplsql) diff --git a/src/lib/impala/ImpalaSqlLexer.interp b/src/lib/impala/ImpalaSqlLexer.interp new file mode 100644 index 0000000..9fd52f4 --- /dev/null +++ b/src/lib/impala/ImpalaSqlLexer.interp @@ -0,0 +1,830 @@ +token literal names: +null +'ADD' +'ALL' +'ANALYTIC' +'ALTER' +'AND' +'ANY' +'ANTI' +'ARRAY' +'AS' +'ASC' +'AT' +'AGGREGATE' +'AUTHORIZATION' +'BERNOULLI' +'BETWEEN' +'BLOCK_SIZE' +'PARTITIONED' +'PREPARE_FN' +'EXTERNAL' +'CLOSEFN' +'SORT' +'PURGE' +'STORED' +'LOCATION' +'TBLPROPERTIES' +'BY' +'CASCADE' +'CASE' +'CAST' +'CACHED' +'CHANGE' +'COLUMN' +'COLUMNS' +'COMMENT' +'COMPRESSION' +'COMPUTE' +'CREATE' +'CROSS' +'CURRENT' +'CURRENT_DATE' +'CURRENT_PATH' +'CURRENT_TIME' +'CURRENT_TIMESTAMP' +'CURRENT_USER' +'DATA' +'DATABASE' +'DATABASES' +'DAY' +'DAYS' +'DELETE' +'DEFAULT' +'DELIMITED' +'DISABLE' +'UPDATE' +'DESC' +'DESCRIBE' +'DISTINCT' +'DROP' +'ELSE' +'ENCODING' +'END' +'ESCAPE' +'ESCAPED' +'EXCEPT' +'EXCLUDING' +'EXISTS' +'EXPLAIN' +'EXTRACT' +'EXTENDED' +'FALSE' +'FIELDS' +'FILEFORMAT' +'FILES' +'FILTER' +'FIRST' +'FINALIZE_FN' +'FOLLOWING' +'FOR' +'FORMAT' +'FORMATTED' +'FOREIGN' +'FROM' +'FULL' +'FUNCTION' +'FUNCTIONS' +'GRANT' +'GROUP' +'GROUPING' +'HASH' +'HAVING' +'HOUR' +'HOURS' +'IF' +'IN' +'INCLUDING' +'INCREMENTAL' +'INNER' +'INPATH' +'INSERT' +'INTERSECT' +'INTERVAL' +'INTERMEDIATE' +'INTO' +'INIT_FN' +'INVALIDATE' +'IS' +'JOIN' +'KEY' +'KUDU' +'LAST' +'LATERAL' +'LEFT' +'LIKE' +'LIMIT' +'LINES' +'LOAD' +'LOCALTIME' +'LOCALTIMESTAMP' +'METADATA' +'MAP' +'MINUTE' +'MINUTES' +'MONTH' +'MONTHS' +'MERGE_FN' +'NFC' +'NFD' +'NFKC' +'NFKD' +'NORMALIZE' +'NOT' +'NULL' +'NULLS' +'OFFSET' +'ON' +'OPTION' +'OR' +'ORDER' +'ORDINALITY' +'OUTER' +'OWNER' +'OVER' +'OVERWRITE' +'PARTITION' +'PARTITIONS' +'PARQUET' +'POSITION' +'PRECEDING' +'PRIMARY' +'REPLICATION' +'PRIVILEGES' +'PROPERTIES' +'RANGE' +'RECOVER' +'RENAME' +'REPEATABLE' +'REPLACE' +'RESTRICT' +'RETURNS' +'REVOKE' +'REFRESH' +'REGEXP' +'RLIKE' +'RIGHT' +'ROLE' +'ROLES' +'ROW' +'ROWS' +'SCHEMA' +'SCHEMAS' +'SECOND' +'SECONDS' +'SELECT' +'SERDEPROPERTIES' +'SET' +'SEMI' +'SERVER' +'SHOW' +'SHUTDOWN' +'SOME' +'STATS' +'STRUCT' +'STRAIGHT_JOIN' +'SUBSTRING' +'SYSTEM' +'SYMBOL' +'SERIALIZE_FN' +'TABLE' +'TABLES' +'TABLESAMPLE' +'TERMINATED ' +'THEN' +'TO' +'TRUE' +'TRY_CAST' +'TRUNCATE' +'UNCACHED' +'UESCAPE' +'UNBOUNDED' +'UNION' +'UNNEST' +'UNSET' +'USE' +'USER' +'USING' +'UPDATE_FN' +'UPSERT' +'URI' +'VALUE' +'VALUES' +'VIEW' +'VIEWS' +'WHEN' +'WHERE' +'WITH' +'YEAR' +'YEARS' +'TEXTFILE' +'ORC' +'AVRO' +'SEQUENCEFILE' +'RCFILE' +'REFERENCES' +'NOVALIDATE' +'RELY' +'\'NUMDVS\'' +'\'NUMNULLS\'' +'\'AVGSIZE\'' +'\'MAXSIZE\'' +'=' +null +'<' +'<=' +'>' +'>=' +'+' +'-' +'*' +'/' +'%' +'||' +'.' +';' +',' +':' +'(' +')' +'[' +']' +'{' +'}' +'|' +'?' +'->' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +KW_ADD +KW_ALL +KW_ANALYTIC +KW_ALTER +KW_AND +KW_ANY +KW_ANTI +KW_ARRAY +KW_AS +KW_ASC +KW_AT +KW_AGGREGATE +KW_AUTHORIZATION +KW_BERNOULLI +KW_BETWEEN +KW_BLOCK_SIZE +KW_PARTITIONED +KW_PREPARE_FN +KW_EXTERNAL +KW_CLOSEFN +KW_SORT +KW_PURGE +KW_STORED +KW_LOCATION +KW_TBLPROPERTIES +KW_BY +KW_CASCADE +KW_CASE +KW_CAST +KW_CACHED +KW_CHANGE +KW_COLUMN +KW_COLUMNS +KW_COMMENT +KW_COMPRESSION +KW_COMPUTE +KW_CREATE +KW_CROSS +KW_CURRENT +KW_CURRENT_DATE +KW_CURRENT_PATH +KW_CURRENT_TIME +KW_CURRENT_TIMESTAMP +KW_CURRENT_USER +KW_DATA +KW_DATABASE +KW_DATABASES +KW_DAY +KW_DAYS +KW_DELETE +KW_DEFAULT +KW_DELIMITED +KW_DISABLE +KW_UPDATE +KW_DESC +KW_DESCRIBE +KW_DISTINCT +KW_DROP +KW_ELSE +KW_ENCODING +KW_END +KW_ESCAPE +KW_ESCAPED +KW_EXCEPT +KW_EXCLUDING +KW_EXISTS +KW_EXPLAIN +KW_EXTRACT +KW_EXTENDED +KW_FALSE +KW_FIELDS +KW_FILEFORMAT +KW_FILES +KW_FILTER +KW_FIRST +KW_FINALIZE_FN +KW_FOLLOWING +KW_FOR +KW_FORMAT +KW_FORMATTED +KW_FOREIGN +KW_FROM +KW_FULL +KW_FUNCTION +KW_FUNCTIONS +KW_GRANT +KW_GROUP +KW_GROUPING +KW_HASH +KW_HAVING +KW_HOUR +KW_HOURS +KW_IF +KW_IN +KW_INCLUDING +KW_INCREMENTAL +KW_INNER +KW_INPATH +KW_INSERT +KW_INTERSECT +KW_INTERVAL +KW_INTERMEDIATE +KW_INTO +KW_INIT_FN +KW_INVALIDATE +KW_IS +KW_JOIN +KW_KEY +KW_KUDU +KW_LAST +KW_LATERAL +KW_LEFT +KW_LIKE +KW_LIMIT +KW_LINES +KW_LOAD +KW_LOCALTIME +KW_LOCALTIMESTAMP +KW_METADATA +KW_MAP +KW_MINUTE +KW_MINUTES +KW_MONTH +KW_MONTHS +KW_MERGE_FN +KW_NFC +KW_NFD +KW_NFKC +KW_NFKD +KW_NORMALIZE +KW_NOT +KW_NULL +KW_NULLS +KW_OFFSET +KW_ON +KW_OPTION +KW_OR +KW_ORDER +KW_ORDINALITY +KW_OUTER +KW_OWNER +KW_OVER +KW_OVERWRITE +KW_PARTITION +KW_PARTITIONS +KW_PARQUET +KW_POSITION +KW_PRECEDING +KW_PRIMARY +KW_REPLICATION +KW_PRIVILEGES +KW_PROPERTIES +KW_RANGE +KW_RECOVER +KW_RENAME +KW_REPEATABLE +KW_REPLACE +KW_RESTRICT +KW_RETURNS +KW_REVOKE +KW_REFRESH +KW_REGEXP +KW_RLIKE +KW_RIGHT +KW_ROLE +KW_ROLES +KW_ROW +KW_ROWS +KW_SCHEMA +KW_SCHEMAS +KW_SECOND +KW_SECONDS +KW_SELECT +KW_SERDEPROPERTIES +KW_SET +KW_SEMI +KW_SERVER +KW_SHOW +KW_SHUTDOWN +KW_SOME +KW_STATS +KW_STRUCT +KW_STRAIGHT_JOIN +KW_SUBSTRING +KW_SYSTEM +KW_SYMBOL +KW_SERIALIZE_FN +KW_TABLE +KW_TABLES +KW_TABLESAMPLE +KW_TERMINATED +KW_THEN +KW_TO +KW_TRUE +KW_TRY_CAST +KW_TRUNCATE +KW_UNCACHED +KW_UESCAPE +KW_UNBOUNDED +KW_UNION +KW_UNNEST +KW_UNSET +KW_USE +KW_USER +KW_USING +KW_UPDATE_FN +KW_UPSERT +KW_URI +KW_VALUE +KW_VALUES +KW_VIEW +KW_VIEWS +KW_WHEN +KW_WHERE +KW_WITH +KW_YEAR +KW_YEARS +KW_TEXTFILE +KW_ORC +KW_AVRO +KW_SEQUENCEFILE +KW_RCFILE +KW_REFERENCES +KW_NOVALIDATE +KW_RELY +STATS_NUMDVS +STATS_NUMNULLS +STATS_AVGSIZE +STATS_MAXSIZE +EQ +NEQ +LT +LTE +GT +GTE +PLUS +MINUS +ASTERISK +SLASH +PERCENT +CONCAT +DOT +SEMICOLON +COMMA +COLON +LPAREN +RPAREN +LSQUARE +RSQUARE +LCURLY +RCURLY +BITWISEOR +QUESTION +RIGHT_ARROW +STRING +UNICODE_STRING +BINARY_LITERAL +INTEGER_VALUE +DECIMAL_VALUE +DOUBLE_VALUE +IDENTIFIER +DIGIT_IDENTIFIER +QUOTED_IDENTIFIER +BACKQUOTED_IDENTIFIER +TIME_WITH_TIME_ZONE +TIMESTAMP_WITH_TIME_ZONE +DOUBLE_PRECISION +SIMPLE_COMMENT +BRACKETED_COMMENT +WS + +rule names: +KW_ADD +KW_ALL +KW_ANALYTIC +KW_ALTER +KW_AND +KW_ANY +KW_ANTI +KW_ARRAY +KW_AS +KW_ASC +KW_AT +KW_AGGREGATE +KW_AUTHORIZATION +KW_BERNOULLI +KW_BETWEEN +KW_BLOCK_SIZE +KW_PARTITIONED +KW_PREPARE_FN +KW_EXTERNAL +KW_CLOSEFN +KW_SORT +KW_PURGE +KW_STORED +KW_LOCATION +KW_TBLPROPERTIES +KW_BY +KW_CASCADE +KW_CASE +KW_CAST +KW_CACHED +KW_CHANGE +KW_COLUMN +KW_COLUMNS +KW_COMMENT +KW_COMPRESSION +KW_COMPUTE +KW_CREATE +KW_CROSS +KW_CURRENT +KW_CURRENT_DATE +KW_CURRENT_PATH +KW_CURRENT_TIME +KW_CURRENT_TIMESTAMP +KW_CURRENT_USER +KW_DATA +KW_DATABASE +KW_DATABASES +KW_DAY +KW_DAYS +KW_DELETE +KW_DEFAULT +KW_DELIMITED +KW_DISABLE +KW_UPDATE +KW_DESC +KW_DESCRIBE +KW_DISTINCT +KW_DROP +KW_ELSE +KW_ENCODING +KW_END +KW_ESCAPE +KW_ESCAPED +KW_EXCEPT +KW_EXCLUDING +KW_EXISTS +KW_EXPLAIN +KW_EXTRACT +KW_EXTENDED +KW_FALSE +KW_FIELDS +KW_FILEFORMAT +KW_FILES +KW_FILTER +KW_FIRST +KW_FINALIZE_FN +KW_FOLLOWING +KW_FOR +KW_FORMAT +KW_FORMATTED +KW_FOREIGN +KW_FROM +KW_FULL +KW_FUNCTION +KW_FUNCTIONS +KW_GRANT +KW_GROUP +KW_GROUPING +KW_HASH +KW_HAVING +KW_HOUR +KW_HOURS +KW_IF +KW_IN +KW_INCLUDING +KW_INCREMENTAL +KW_INNER +KW_INPATH +KW_INSERT +KW_INTERSECT +KW_INTERVAL +KW_INTERMEDIATE +KW_INTO +KW_INIT_FN +KW_INVALIDATE +KW_IS +KW_JOIN +KW_KEY +KW_KUDU +KW_LAST +KW_LATERAL +KW_LEFT +KW_LIKE +KW_LIMIT +KW_LINES +KW_LOAD +KW_LOCALTIME +KW_LOCALTIMESTAMP +KW_METADATA +KW_MAP +KW_MINUTE +KW_MINUTES +KW_MONTH +KW_MONTHS +KW_MERGE_FN +KW_NFC +KW_NFD +KW_NFKC +KW_NFKD +KW_NORMALIZE +KW_NOT +KW_NULL +KW_NULLS +KW_OFFSET +KW_ON +KW_OPTION +KW_OR +KW_ORDER +KW_ORDINALITY +KW_OUTER +KW_OWNER +KW_OVER +KW_OVERWRITE +KW_PARTITION +KW_PARTITIONS +KW_PARQUET +KW_POSITION +KW_PRECEDING +KW_PRIMARY +KW_REPLICATION +KW_PRIVILEGES +KW_PROPERTIES +KW_RANGE +KW_RECOVER +KW_RENAME +KW_REPEATABLE +KW_REPLACE +KW_RESTRICT +KW_RETURNS +KW_REVOKE +KW_REFRESH +KW_REGEXP +KW_RLIKE +KW_RIGHT +KW_ROLE +KW_ROLES +KW_ROW +KW_ROWS +KW_SCHEMA +KW_SCHEMAS +KW_SECOND +KW_SECONDS +KW_SELECT +KW_SERDEPROPERTIES +KW_SET +KW_SEMI +KW_SERVER +KW_SHOW +KW_SHUTDOWN +KW_SOME +KW_STATS +KW_STRUCT +KW_STRAIGHT_JOIN +KW_SUBSTRING +KW_SYSTEM +KW_SYMBOL +KW_SERIALIZE_FN +KW_TABLE +KW_TABLES +KW_TABLESAMPLE +KW_TERMINATED +KW_THEN +KW_TO +KW_TRUE +KW_TRY_CAST +KW_TRUNCATE +KW_UNCACHED +KW_UESCAPE +KW_UNBOUNDED +KW_UNION +KW_UNNEST +KW_UNSET +KW_USE +KW_USER +KW_USING +KW_UPDATE_FN +KW_UPSERT +KW_URI +KW_VALUE +KW_VALUES +KW_VIEW +KW_VIEWS +KW_WHEN +KW_WHERE +KW_WITH +KW_YEAR +KW_YEARS +KW_TEXTFILE +KW_ORC +KW_AVRO +KW_SEQUENCEFILE +KW_RCFILE +KW_REFERENCES +KW_NOVALIDATE +KW_RELY +STATS_NUMDVS +STATS_NUMNULLS +STATS_AVGSIZE +STATS_MAXSIZE +EQ +NEQ +LT +LTE +GT +GTE +PLUS +MINUS +ASTERISK +SLASH +PERCENT +CONCAT +DOT +SEMICOLON +COMMA +COLON +LPAREN +RPAREN +LSQUARE +RSQUARE +LCURLY +RCURLY +BITWISEOR +QUESTION +RIGHT_ARROW +STRING +UNICODE_STRING +BINARY_LITERAL +INTEGER_VALUE +DECIMAL_VALUE +DOUBLE_VALUE +IDENTIFIER +DIGIT_IDENTIFIER +QUOTED_IDENTIFIER +BACKQUOTED_IDENTIFIER +TIME_WITH_TIME_ZONE +TIMESTAMP_WITH_TIME_ZONE +DOUBLE_PRECISION +EXPONENT +DIGIT +LETTER +SIMPLE_COMMENT +BRACKETED_COMMENT +WS + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[3, 51485, 51898, 1421, 44986, 20307, 1543, 60043, 49729, 2, 272, 2574, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142, 4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147, 9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151, 4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156, 9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160, 4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165, 9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 4, 168, 9, 168, 4, 169, 9, 169, 4, 170, 9, 170, 4, 171, 9, 171, 4, 172, 9, 172, 4, 173, 9, 173, 4, 174, 9, 174, 4, 175, 9, 175, 4, 176, 9, 176, 4, 177, 9, 177, 4, 178, 9, 178, 4, 179, 9, 179, 4, 180, 9, 180, 4, 181, 9, 181, 4, 182, 9, 182, 4, 183, 9, 183, 4, 184, 9, 184, 4, 185, 9, 185, 4, 186, 9, 186, 4, 187, 9, 187, 4, 188, 9, 188, 4, 189, 9, 189, 4, 190, 9, 190, 4, 191, 9, 191, 4, 192, 9, 192, 4, 193, 9, 193, 4, 194, 9, 194, 4, 195, 9, 195, 4, 196, 9, 196, 4, 197, 9, 197, 4, 198, 9, 198, 4, 199, 9, 199, 4, 200, 9, 200, 4, 201, 9, 201, 4, 202, 9, 202, 4, 203, 9, 203, 4, 204, 9, 204, 4, 205, 9, 205, 4, 206, 9, 206, 4, 207, 9, 207, 4, 208, 9, 208, 4, 209, 9, 209, 4, 210, 9, 210, 4, 211, 9, 211, 4, 212, 9, 212, 4, 213, 9, 213, 4, 214, 9, 214, 4, 215, 9, 215, 4, 216, 9, 216, 4, 217, 9, 217, 4, 218, 9, 218, 4, 219, 9, 219, 4, 220, 9, 220, 4, 221, 9, 221, 4, 222, 9, 222, 4, 223, 9, 223, 4, 224, 9, 224, 4, 225, 9, 225, 4, 226, 9, 226, 4, 227, 9, 227, 4, 228, 9, 228, 4, 229, 9, 229, 4, 230, 9, 230, 4, 231, 9, 231, 4, 232, 9, 232, 4, 233, 9, 233, 4, 234, 9, 234, 4, 235, 9, 235, 4, 236, 9, 236, 4, 237, 9, 237, 4, 238, 9, 238, 4, 239, 9, 239, 4, 240, 9, 240, 4, 241, 9, 241, 4, 242, 9, 242, 4, 243, 9, 243, 4, 244, 9, 244, 4, 245, 9, 245, 4, 246, 9, 246, 4, 247, 9, 247, 4, 248, 9, 248, 4, 249, 9, 249, 4, 250, 9, 250, 4, 251, 9, 251, 4, 252, 9, 252, 4, 253, 9, 253, 4, 254, 9, 254, 4, 255, 9, 255, 4, 256, 9, 256, 4, 257, 9, 257, 4, 258, 9, 258, 4, 259, 9, 259, 4, 260, 9, 260, 4, 261, 9, 261, 4, 262, 9, 262, 4, 263, 9, 263, 4, 264, 9, 264, 4, 265, 9, 265, 4, 266, 9, 266, 4, 267, 9, 267, 4, 268, 9, 268, 4, 269, 9, 269, 4, 270, 9, 270, 4, 271, 9, 271, 4, 272, 9, 272, 4, 273, 9, 273, 4, 274, 9, 274, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 6, 3, 6, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 79, 3, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 3, 92, 3, 92, 3, 92, 3, 92, 3, 92, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 94, 3, 94, 3, 94, 3, 95, 3, 95, 3, 95, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 97, 3, 97, 3, 97, 3, 97, 3, 97, 3, 97, 3, 97, 3, 97, 3, 97, 3, 97, 3, 97, 3, 97, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 3, 104, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 107, 3, 107, 3, 107, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 109, 3, 109, 3, 109, 3, 109, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 121, 3, 121, 3, 121, 3, 121, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 127, 3, 127, 3, 127, 3, 127, 3, 128, 3, 128, 3, 128, 3, 128, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 132, 3, 132, 3, 132, 3, 132, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 136, 3, 136, 3, 136, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 138, 3, 138, 3, 138, 3, 139, 3, 139, 3, 139, 3, 139, 3, 139, 3, 139, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 151, 3, 151, 3, 151, 3, 151, 3, 151, 3, 151, 3, 151, 3, 151, 3, 151, 3, 151, 3, 151, 3, 151, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 161, 3, 161, 3, 161, 3, 161, 3, 161, 3, 161, 3, 161, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 168, 3, 168, 3, 168, 3, 168, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 176, 3, 176, 3, 176, 3, 176, 3, 177, 3, 177, 3, 177, 3, 177, 3, 177, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 181, 3, 181, 3, 181, 3, 181, 3, 181, 3, 182, 3, 182, 3, 182, 3, 182, 3, 182, 3, 182, 3, 183, 3, 183, 3, 183, 3, 183, 3, 183, 3, 183, 3, 183, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 194, 3, 194, 3, 194, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 198, 3, 198, 3, 198, 3, 198, 3, 198, 3, 198, 3, 198, 3, 198, 3, 198, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 202, 3, 202, 3, 202, 3, 202, 3, 202, 3, 202, 3, 202, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 204, 3, 204, 3, 204, 3, 204, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 3, 208, 3, 208, 3, 208, 3, 208, 3, 208, 3, 208, 3, 208, 3, 209, 3, 209, 3, 209, 3, 209, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 211, 3, 211, 3, 211, 3, 211, 3, 211, 3, 211, 3, 211, 3, 212, 3, 212, 3, 212, 3, 212, 3, 212, 3, 213, 3, 213, 3, 213, 3, 213, 3, 213, 3, 213, 3, 214, 3, 214, 3, 214, 3, 214, 3, 214, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 216, 3, 216, 3, 216, 3, 216, 3, 216, 3, 217, 3, 217, 3, 217, 3, 217, 3, 217, 3, 218, 3, 218, 3, 218, 3, 218, 3, 218, 3, 218, 3, 219, 3, 219, 3, 219, 3, 219, 3, 219, 3, 219, 3, 219, 3, 219, 3, 219, 3, 220, 3, 220, 3, 220, 3, 220, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 231, 3, 231, 3, 232, 3, 232, 3, 232, 3, 232, 5, 232, 2263, 10, 232, 3, 233, 3, 233, 3, 234, 3, 234, 3, 234, 3, 235, 3, 235, 3, 236, 3, 236, 3, 236, 3, 237, 3, 237, 3, 238, 3, 238, 3, 239, 3, 239, 3, 240, 3, 240, 3, 241, 3, 241, 3, 242, 3, 242, 3, 242, 3, 243, 3, 243, 3, 244, 3, 244, 3, 245, 3, 245, 3, 246, 3, 246, 3, 247, 3, 247, 3, 248, 3, 248, 3, 249, 3, 249, 3, 250, 3, 250, 3, 251, 3, 251, 3, 252, 3, 252, 3, 253, 3, 253, 3, 254, 3, 254, 3, 255, 3, 255, 3, 255, 3, 256, 3, 256, 3, 256, 3, 256, 7, 256, 2319, 10, 256, 12, 256, 14, 256, 2322, 11, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 7, 256, 2329, 10, 256, 12, 256, 14, 256, 2332, 11, 256, 3, 256, 5, 256, 2335, 10, 256, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 7, 257, 2344, 10, 257, 12, 257, 14, 257, 2347, 11, 257, 3, 257, 3, 257, 3, 258, 3, 258, 3, 258, 3, 258, 7, 258, 2355, 10, 258, 12, 258, 14, 258, 2358, 11, 258, 3, 258, 3, 258, 3, 259, 6, 259, 2363, 10, 259, 13, 259, 14, 259, 2364, 3, 260, 6, 260, 2368, 10, 260, 13, 260, 14, 260, 2369, 3, 260, 3, 260, 7, 260, 2374, 10, 260, 12, 260, 14, 260, 2377, 11, 260, 3, 260, 3, 260, 6, 260, 2381, 10, 260, 13, 260, 14, 260, 2382, 5, 260, 2385, 10, 260, 3, 261, 6, 261, 2388, 10, 261, 13, 261, 14, 261, 2389, 3, 261, 3, 261, 7, 261, 2394, 10, 261, 12, 261, 14, 261, 2397, 11, 261, 5, 261, 2399, 10, 261, 3, 261, 3, 261, 3, 261, 3, 261, 6, 261, 2405, 10, 261, 13, 261, 14, 261, 2406, 3, 261, 3, 261, 5, 261, 2411, 10, 261, 3, 262, 3, 262, 5, 262, 2415, 10, 262, 3, 262, 3, 262, 3, 262, 7, 262, 2420, 10, 262, 12, 262, 14, 262, 2423, 11, 262, 3, 263, 3, 263, 3, 263, 3, 263, 6, 263, 2429, 10, 263, 13, 263, 14, 263, 2430, 3, 264, 3, 264, 3, 264, 3, 264, 7, 264, 2437, 10, 264, 12, 264, 14, 264, 2440, 11, 264, 3, 264, 3, 264, 3, 265, 3, 265, 3, 265, 3, 265, 7, 265, 2448, 10, 265, 12, 265, 14, 265, 2451, 11, 265, 3, 265, 3, 265, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 269, 3, 269, 5, 269, 2526, 10, 269, 3, 269, 6, 269, 2529, 10, 269, 13, 269, 14, 269, 2530, 3, 270, 3, 270, 3, 271, 3, 271, 3, 272, 3, 272, 3, 272, 3, 272, 7, 272, 2541, 10, 272, 12, 272, 14, 272, 2544, 11, 272, 3, 272, 5, 272, 2547, 10, 272, 3, 272, 5, 272, 2550, 10, 272, 3, 272, 3, 272, 3, 273, 3, 273, 3, 273, 3, 273, 7, 273, 2558, 10, 273, 12, 273, 14, 273, 2561, 11, 273, 3, 273, 3, 273, 3, 273, 3, 273, 3, 273, 3, 274, 6, 274, 2569, 10, 274, 13, 274, 14, 274, 2570, 3, 274, 3, 274, 3, 2559, 2, 2, 275, 3, 2, 3, 5, 2, 4, 7, 2, 5, 9, 2, 6, 11, 2, 7, 13, 2, 8, 15, 2, 9, 17, 2, 10, 19, 2, 11, 21, 2, 12, 23, 2, 13, 25, 2, 14, 27, 2, 15, 29, 2, 16, 31, 2, 17, 33, 2, 18, 35, 2, 19, 37, 2, 20, 39, 2, 21, 41, 2, 22, 43, 2, 23, 45, 2, 24, 47, 2, 25, 49, 2, 26, 51, 2, 27, 53, 2, 28, 55, 2, 29, 57, 2, 30, 59, 2, 31, 61, 2, 32, 63, 2, 33, 65, 2, 34, 67, 2, 35, 69, 2, 36, 71, 2, 37, 73, 2, 38, 75, 2, 39, 77, 2, 40, 79, 2, 41, 81, 2, 42, 83, 2, 43, 85, 2, 44, 87, 2, 45, 89, 2, 46, 91, 2, 47, 93, 2, 48, 95, 2, 49, 97, 2, 50, 99, 2, 51, 101, 2, 52, 103, 2, 53, 105, 2, 54, 107, 2, 55, 109, 2, 56, 111, 2, 57, 113, 2, 58, 115, 2, 59, 117, 2, 60, 119, 2, 61, 121, 2, 62, 123, 2, 63, 125, 2, 64, 127, 2, 65, 129, 2, 66, 131, 2, 67, 133, 2, 68, 135, 2, 69, 137, 2, 70, 139, 2, 71, 141, 2, 72, 143, 2, 73, 145, 2, 74, 147, 2, 75, 149, 2, 76, 151, 2, 77, 153, 2, 78, 155, 2, 79, 157, 2, 80, 159, 2, 81, 161, 2, 82, 163, 2, 83, 165, 2, 84, 167, 2, 85, 169, 2, 86, 171, 2, 87, 173, 2, 88, 175, 2, 89, 177, 2, 90, 179, 2, 91, 181, 2, 92, 183, 2, 93, 185, 2, 94, 187, 2, 95, 189, 2, 96, 191, 2, 97, 193, 2, 98, 195, 2, 99, 197, 2, 100, 199, 2, 101, 201, 2, 102, 203, 2, 103, 205, 2, 104, 207, 2, 105, 209, 2, 106, 211, 2, 107, 213, 2, 108, 215, 2, 109, 217, 2, 110, 219, 2, 111, 221, 2, 112, 223, 2, 113, 225, 2, 114, 227, 2, 115, 229, 2, 116, 231, 2, 117, 233, 2, 118, 235, 2, 119, 237, 2, 120, 239, 2, 121, 241, 2, 122, 243, 2, 123, 245, 2, 124, 247, 2, 125, 249, 2, 126, 251, 2, 127, 253, 2, 128, 255, 2, 129, 257, 2, 130, 259, 2, 131, 261, 2, 132, 263, 2, 133, 265, 2, 134, 267, 2, 135, 269, 2, 136, 271, 2, 137, 273, 2, 138, 275, 2, 139, 277, 2, 140, 279, 2, 141, 281, 2, 142, 283, 2, 143, 285, 2, 144, 287, 2, 145, 289, 2, 146, 291, 2, 147, 293, 2, 148, 295, 2, 149, 297, 2, 150, 299, 2, 151, 301, 2, 152, 303, 2, 153, 305, 2, 154, 307, 2, 155, 309, 2, 156, 311, 2, 157, 313, 2, 158, 315, 2, 159, 317, 2, 160, 319, 2, 161, 321, 2, 162, 323, 2, 163, 325, 2, 164, 327, 2, 165, 329, 2, 166, 331, 2, 167, 333, 2, 168, 335, 2, 169, 337, 2, 170, 339, 2, 171, 341, 2, 172, 343, 2, 173, 345, 2, 174, 347, 2, 175, 349, 2, 176, 351, 2, 177, 353, 2, 178, 355, 2, 179, 357, 2, 180, 359, 2, 181, 361, 2, 182, 363, 2, 183, 365, 2, 184, 367, 2, 185, 369, 2, 186, 371, 2, 187, 373, 2, 188, 375, 2, 189, 377, 2, 190, 379, 2, 191, 381, 2, 192, 383, 2, 193, 385, 2, 194, 387, 2, 195, 389, 2, 196, 391, 2, 197, 393, 2, 198, 395, 2, 199, 397, 2, 200, 399, 2, 201, 401, 2, 202, 403, 2, 203, 405, 2, 204, 407, 2, 205, 409, 2, 206, 411, 2, 207, 413, 2, 208, 415, 2, 209, 417, 2, 210, 419, 2, 211, 421, 2, 212, 423, 2, 213, 425, 2, 214, 427, 2, 215, 429, 2, 216, 431, 2, 217, 433, 2, 218, 435, 2, 219, 437, 2, 220, 439, 2, 221, 441, 2, 222, 443, 2, 223, 445, 2, 224, 447, 2, 225, 449, 2, 226, 451, 2, 227, 453, 2, 228, 455, 2, 229, 457, 2, 230, 459, 2, 231, 461, 2, 232, 463, 2, 233, 465, 2, 234, 467, 2, 235, 469, 2, 236, 471, 2, 237, 473, 2, 238, 475, 2, 239, 477, 2, 240, 479, 2, 241, 481, 2, 242, 483, 2, 243, 485, 2, 244, 487, 2, 245, 489, 2, 246, 491, 2, 247, 493, 2, 248, 495, 2, 249, 497, 2, 250, 499, 2, 251, 501, 2, 252, 503, 2, 253, 505, 2, 254, 507, 2, 255, 509, 2, 256, 511, 2, 257, 513, 2, 258, 515, 2, 259, 517, 2, 260, 519, 2, 261, 521, 2, 262, 523, 2, 263, 525, 2, 264, 527, 2, 265, 529, 2, 266, 531, 2, 267, 533, 2, 268, 535, 2, 269, 537, 2, 2, 539, 2, 2, 541, 2, 2, 543, 2, 270, 545, 2, 271, 547, 2, 272, 3, 2, 11, 3, 2, 41, 41, 3, 2, 36, 36, 5, 2, 60, 60, 66, 66, 97, 97, 3, 2, 98, 98, 4, 2, 45, 45, 47, 47, 3, 2, 50, 59, 3, 2, 67, 92, 4, 2, 12, 12, 15, 15, 5, 2, 11, 12, 15, 15, 34, 34, 2, 2607, 2, 3, 3, 2, 2, 2, 2, 5, 3, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2, 2, 2, 2, 15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 3, 2, 2, 2, 2, 21, 3, 2, 2, 2, 2, 23, 3, 2, 2, 2, 2, 25, 3, 2, 2, 2, 2, 27, 3, 2, 2, 2, 2, 29, 3, 2, 2, 2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2, 37, 3, 2, 2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2, 2, 45, 3, 2, 2, 2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3, 2, 2, 2, 2, 53, 3, 2, 2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59, 3, 2, 2, 2, 2, 61, 3, 2, 2, 2, 2, 63, 3, 2, 2, 2, 2, 65, 3, 2, 2, 2, 2, 67, 3, 2, 2, 2, 2, 69, 3, 2, 2, 2, 2, 71, 3, 2, 2, 2, 2, 73, 3, 2, 2, 2, 2, 75, 3, 2, 2, 2, 2, 77, 3, 2, 2, 2, 2, 79, 3, 2, 2, 2, 2, 81, 3, 2, 2, 2, 2, 83, 3, 2, 2, 2, 2, 85, 3, 2, 2, 2, 2, 87, 3, 2, 2, 2, 2, 89, 3, 2, 2, 2, 2, 91, 3, 2, 2, 2, 2, 93, 3, 2, 2, 2, 2, 95, 3, 2, 2, 2, 2, 97, 3, 2, 2, 2, 2, 99, 3, 2, 2, 2, 2, 101, 3, 2, 2, 2, 2, 103, 3, 2, 2, 2, 2, 105, 3, 2, 2, 2, 2, 107, 3, 2, 2, 2, 2, 109, 3, 2, 2, 2, 2, 111, 3, 2, 2, 2, 2, 113, 3, 2, 2, 2, 2, 115, 3, 2, 2, 2, 2, 117, 3, 2, 2, 2, 2, 119, 3, 2, 2, 2, 2, 121, 3, 2, 2, 2, 2, 123, 3, 2, 2, 2, 2, 125, 3, 2, 2, 2, 2, 127, 3, 2, 2, 2, 2, 129, 3, 2, 2, 2, 2, 131, 3, 2, 2, 2, 2, 133, 3, 2, 2, 2, 2, 135, 3, 2, 2, 2, 2, 137, 3, 2, 2, 2, 2, 139, 3, 2, 2, 2, 2, 141, 3, 2, 2, 2, 2, 143, 3, 2, 2, 2, 2, 145, 3, 2, 2, 2, 2, 147, 3, 2, 2, 2, 2, 149, 3, 2, 2, 2, 2, 151, 3, 2, 2, 2, 2, 153, 3, 2, 2, 2, 2, 155, 3, 2, 2, 2, 2, 157, 3, 2, 2, 2, 2, 159, 3, 2, 2, 2, 2, 161, 3, 2, 2, 2, 2, 163, 3, 2, 2, 2, 2, 165, 3, 2, 2, 2, 2, 167, 3, 2, 2, 2, 2, 169, 3, 2, 2, 2, 2, 171, 3, 2, 2, 2, 2, 173, 3, 2, 2, 2, 2, 175, 3, 2, 2, 2, 2, 177, 3, 2, 2, 2, 2, 179, 3, 2, 2, 2, 2, 181, 3, 2, 2, 2, 2, 183, 3, 2, 2, 2, 2, 185, 3, 2, 2, 2, 2, 187, 3, 2, 2, 2, 2, 189, 3, 2, 2, 2, 2, 191, 3, 2, 2, 2, 2, 193, 3, 2, 2, 2, 2, 195, 3, 2, 2, 2, 2, 197, 3, 2, 2, 2, 2, 199, 3, 2, 2, 2, 2, 201, 3, 2, 2, 2, 2, 203, 3, 2, 2, 2, 2, 205, 3, 2, 2, 2, 2, 207, 3, 2, 2, 2, 2, 209, 3, 2, 2, 2, 2, 211, 3, 2, 2, 2, 2, 213, 3, 2, 2, 2, 2, 215, 3, 2, 2, 2, 2, 217, 3, 2, 2, 2, 2, 219, 3, 2, 2, 2, 2, 221, 3, 2, 2, 2, 2, 223, 3, 2, 2, 2, 2, 225, 3, 2, 2, 2, 2, 227, 3, 2, 2, 2, 2, 229, 3, 2, 2, 2, 2, 231, 3, 2, 2, 2, 2, 233, 3, 2, 2, 2, 2, 235, 3, 2, 2, 2, 2, 237, 3, 2, 2, 2, 2, 239, 3, 2, 2, 2, 2, 241, 3, 2, 2, 2, 2, 243, 3, 2, 2, 2, 2, 245, 3, 2, 2, 2, 2, 247, 3, 2, 2, 2, 2, 249, 3, 2, 2, 2, 2, 251, 3, 2, 2, 2, 2, 253, 3, 2, 2, 2, 2, 255, 3, 2, 2, 2, 2, 257, 3, 2, 2, 2, 2, 259, 3, 2, 2, 2, 2, 261, 3, 2, 2, 2, 2, 263, 3, 2, 2, 2, 2, 265, 3, 2, 2, 2, 2, 267, 3, 2, 2, 2, 2, 269, 3, 2, 2, 2, 2, 271, 3, 2, 2, 2, 2, 273, 3, 2, 2, 2, 2, 275, 3, 2, 2, 2, 2, 277, 3, 2, 2, 2, 2, 279, 3, 2, 2, 2, 2, 281, 3, 2, 2, 2, 2, 283, 3, 2, 2, 2, 2, 285, 3, 2, 2, 2, 2, 287, 3, 2, 2, 2, 2, 289, 3, 2, 2, 2, 2, 291, 3, 2, 2, 2, 2, 293, 3, 2, 2, 2, 2, 295, 3, 2, 2, 2, 2, 297, 3, 2, 2, 2, 2, 299, 3, 2, 2, 2, 2, 301, 3, 2, 2, 2, 2, 303, 3, 2, 2, 2, 2, 305, 3, 2, 2, 2, 2, 307, 3, 2, 2, 2, 2, 309, 3, 2, 2, 2, 2, 311, 3, 2, 2, 2, 2, 313, 3, 2, 2, 2, 2, 315, 3, 2, 2, 2, 2, 317, 3, 2, 2, 2, 2, 319, 3, 2, 2, 2, 2, 321, 3, 2, 2, 2, 2, 323, 3, 2, 2, 2, 2, 325, 3, 2, 2, 2, 2, 327, 3, 2, 2, 2, 2, 329, 3, 2, 2, 2, 2, 331, 3, 2, 2, 2, 2, 333, 3, 2, 2, 2, 2, 335, 3, 2, 2, 2, 2, 337, 3, 2, 2, 2, 2, 339, 3, 2, 2, 2, 2, 341, 3, 2, 2, 2, 2, 343, 3, 2, 2, 2, 2, 345, 3, 2, 2, 2, 2, 347, 3, 2, 2, 2, 2, 349, 3, 2, 2, 2, 2, 351, 3, 2, 2, 2, 2, 353, 3, 2, 2, 2, 2, 355, 3, 2, 2, 2, 2, 357, 3, 2, 2, 2, 2, 359, 3, 2, 2, 2, 2, 361, 3, 2, 2, 2, 2, 363, 3, 2, 2, 2, 2, 365, 3, 2, 2, 2, 2, 367, 3, 2, 2, 2, 2, 369, 3, 2, 2, 2, 2, 371, 3, 2, 2, 2, 2, 373, 3, 2, 2, 2, 2, 375, 3, 2, 2, 2, 2, 377, 3, 2, 2, 2, 2, 379, 3, 2, 2, 2, 2, 381, 3, 2, 2, 2, 2, 383, 3, 2, 2, 2, 2, 385, 3, 2, 2, 2, 2, 387, 3, 2, 2, 2, 2, 389, 3, 2, 2, 2, 2, 391, 3, 2, 2, 2, 2, 393, 3, 2, 2, 2, 2, 395, 3, 2, 2, 2, 2, 397, 3, 2, 2, 2, 2, 399, 3, 2, 2, 2, 2, 401, 3, 2, 2, 2, 2, 403, 3, 2, 2, 2, 2, 405, 3, 2, 2, 2, 2, 407, 3, 2, 2, 2, 2, 409, 3, 2, 2, 2, 2, 411, 3, 2, 2, 2, 2, 413, 3, 2, 2, 2, 2, 415, 3, 2, 2, 2, 2, 417, 3, 2, 2, 2, 2, 419, 3, 2, 2, 2, 2, 421, 3, 2, 2, 2, 2, 423, 3, 2, 2, 2, 2, 425, 3, 2, 2, 2, 2, 427, 3, 2, 2, 2, 2, 429, 3, 2, 2, 2, 2, 431, 3, 2, 2, 2, 2, 433, 3, 2, 2, 2, 2, 435, 3, 2, 2, 2, 2, 437, 3, 2, 2, 2, 2, 439, 3, 2, 2, 2, 2, 441, 3, 2, 2, 2, 2, 443, 3, 2, 2, 2, 2, 445, 3, 2, 2, 2, 2, 447, 3, 2, 2, 2, 2, 449, 3, 2, 2, 2, 2, 451, 3, 2, 2, 2, 2, 453, 3, 2, 2, 2, 2, 455, 3, 2, 2, 2, 2, 457, 3, 2, 2, 2, 2, 459, 3, 2, 2, 2, 2, 461, 3, 2, 2, 2, 2, 463, 3, 2, 2, 2, 2, 465, 3, 2, 2, 2, 2, 467, 3, 2, 2, 2, 2, 469, 3, 2, 2, 2, 2, 471, 3, 2, 2, 2, 2, 473, 3, 2, 2, 2, 2, 475, 3, 2, 2, 2, 2, 477, 3, 2, 2, 2, 2, 479, 3, 2, 2, 2, 2, 481, 3, 2, 2, 2, 2, 483, 3, 2, 2, 2, 2, 485, 3, 2, 2, 2, 2, 487, 3, 2, 2, 2, 2, 489, 3, 2, 2, 2, 2, 491, 3, 2, 2, 2, 2, 493, 3, 2, 2, 2, 2, 495, 3, 2, 2, 2, 2, 497, 3, 2, 2, 2, 2, 499, 3, 2, 2, 2, 2, 501, 3, 2, 2, 2, 2, 503, 3, 2, 2, 2, 2, 505, 3, 2, 2, 2, 2, 507, 3, 2, 2, 2, 2, 509, 3, 2, 2, 2, 2, 511, 3, 2, 2, 2, 2, 513, 3, 2, 2, 2, 2, 515, 3, 2, 2, 2, 2, 517, 3, 2, 2, 2, 2, 519, 3, 2, 2, 2, 2, 521, 3, 2, 2, 2, 2, 523, 3, 2, 2, 2, 2, 525, 3, 2, 2, 2, 2, 527, 3, 2, 2, 2, 2, 529, 3, 2, 2, 2, 2, 531, 3, 2, 2, 2, 2, 533, 3, 2, 2, 2, 2, 535, 3, 2, 2, 2, 2, 543, 3, 2, 2, 2, 2, 545, 3, 2, 2, 2, 2, 547, 3, 2, 2, 2, 3, 549, 3, 2, 2, 2, 5, 553, 3, 2, 2, 2, 7, 557, 3, 2, 2, 2, 9, 566, 3, 2, 2, 2, 11, 572, 3, 2, 2, 2, 13, 576, 3, 2, 2, 2, 15, 580, 3, 2, 2, 2, 17, 585, 3, 2, 2, 2, 19, 591, 3, 2, 2, 2, 21, 594, 3, 2, 2, 2, 23, 598, 3, 2, 2, 2, 25, 601, 3, 2, 2, 2, 27, 611, 3, 2, 2, 2, 29, 625, 3, 2, 2, 2, 31, 635, 3, 2, 2, 2, 33, 643, 3, 2, 2, 2, 35, 654, 3, 2, 2, 2, 37, 666, 3, 2, 2, 2, 39, 677, 3, 2, 2, 2, 41, 686, 3, 2, 2, 2, 43, 694, 3, 2, 2, 2, 45, 699, 3, 2, 2, 2, 47, 705, 3, 2, 2, 2, 49, 712, 3, 2, 2, 2, 51, 721, 3, 2, 2, 2, 53, 735, 3, 2, 2, 2, 55, 738, 3, 2, 2, 2, 57, 746, 3, 2, 2, 2, 59, 751, 3, 2, 2, 2, 61, 756, 3, 2, 2, 2, 63, 763, 3, 2, 2, 2, 65, 770, 3, 2, 2, 2, 67, 777, 3, 2, 2, 2, 69, 785, 3, 2, 2, 2, 71, 793, 3, 2, 2, 2, 73, 805, 3, 2, 2, 2, 75, 813, 3, 2, 2, 2, 77, 820, 3, 2, 2, 2, 79, 826, 3, 2, 2, 2, 81, 834, 3, 2, 2, 2, 83, 847, 3, 2, 2, 2, 85, 860, 3, 2, 2, 2, 87, 873, 3, 2, 2, 2, 89, 891, 3, 2, 2, 2, 91, 904, 3, 2, 2, 2, 93, 909, 3, 2, 2, 2, 95, 918, 3, 2, 2, 2, 97, 928, 3, 2, 2, 2, 99, 932, 3, 2, 2, 2, 101, 937, 3, 2, 2, 2, 103, 944, 3, 2, 2, 2, 105, 952, 3, 2, 2, 2, 107, 962, 3, 2, 2, 2, 109, 970, 3, 2, 2, 2, 111, 977, 3, 2, 2, 2, 113, 982, 3, 2, 2, 2, 115, 991, 3, 2, 2, 2, 117, 1000, 3, 2, 2, 2, 119, 1005, 3, 2, 2, 2, 121, 1010, 3, 2, 2, 2, 123, 1019, 3, 2, 2, 2, 125, 1023, 3, 2, 2, 2, 127, 1030, 3, 2, 2, 2, 129, 1038, 3, 2, 2, 2, 131, 1045, 3, 2, 2, 2, 133, 1055, 3, 2, 2, 2, 135, 1062, 3, 2, 2, 2, 137, 1070, 3, 2, 2, 2, 139, 1078, 3, 2, 2, 2, 141, 1087, 3, 2, 2, 2, 143, 1093, 3, 2, 2, 2, 145, 1100, 3, 2, 2, 2, 147, 1111, 3, 2, 2, 2, 149, 1117, 3, 2, 2, 2, 151, 1124, 3, 2, 2, 2, 153, 1130, 3, 2, 2, 2, 155, 1142, 3, 2, 2, 2, 157, 1152, 3, 2, 2, 2, 159, 1156, 3, 2, 2, 2, 161, 1163, 3, 2, 2, 2, 163, 1173, 3, 2, 2, 2, 165, 1181, 3, 2, 2, 2, 167, 1186, 3, 2, 2, 2, 169, 1191, 3, 2, 2, 2, 171, 1200, 3, 2, 2, 2, 173, 1210, 3, 2, 2, 2, 175, 1216, 3, 2, 2, 2, 177, 1222, 3, 2, 2, 2, 179, 1231, 3, 2, 2, 2, 181, 1236, 3, 2, 2, 2, 183, 1243, 3, 2, 2, 2, 185, 1248, 3, 2, 2, 2, 187, 1254, 3, 2, 2, 2, 189, 1257, 3, 2, 2, 2, 191, 1260, 3, 2, 2, 2, 193, 1270, 3, 2, 2, 2, 195, 1282, 3, 2, 2, 2, 197, 1288, 3, 2, 2, 2, 199, 1295, 3, 2, 2, 2, 201, 1302, 3, 2, 2, 2, 203, 1312, 3, 2, 2, 2, 205, 1321, 3, 2, 2, 2, 207, 1334, 3, 2, 2, 2, 209, 1339, 3, 2, 2, 2, 211, 1347, 3, 2, 2, 2, 213, 1358, 3, 2, 2, 2, 215, 1361, 3, 2, 2, 2, 217, 1366, 3, 2, 2, 2, 219, 1370, 3, 2, 2, 2, 221, 1375, 3, 2, 2, 2, 223, 1380, 3, 2, 2, 2, 225, 1388, 3, 2, 2, 2, 227, 1393, 3, 2, 2, 2, 229, 1398, 3, 2, 2, 2, 231, 1404, 3, 2, 2, 2, 233, 1410, 3, 2, 2, 2, 235, 1415, 3, 2, 2, 2, 237, 1425, 3, 2, 2, 2, 239, 1440, 3, 2, 2, 2, 241, 1449, 3, 2, 2, 2, 243, 1453, 3, 2, 2, 2, 245, 1460, 3, 2, 2, 2, 247, 1468, 3, 2, 2, 2, 249, 1474, 3, 2, 2, 2, 251, 1481, 3, 2, 2, 2, 253, 1490, 3, 2, 2, 2, 255, 1494, 3, 2, 2, 2, 257, 1498, 3, 2, 2, 2, 259, 1503, 3, 2, 2, 2, 261, 1508, 3, 2, 2, 2, 263, 1518, 3, 2, 2, 2, 265, 1522, 3, 2, 2, 2, 267, 1527, 3, 2, 2, 2, 269, 1533, 3, 2, 2, 2, 271, 1540, 3, 2, 2, 2, 273, 1543, 3, 2, 2, 2, 275, 1550, 3, 2, 2, 2, 277, 1553, 3, 2, 2, 2, 279, 1559, 3, 2, 2, 2, 281, 1570, 3, 2, 2, 2, 283, 1576, 3, 2, 2, 2, 285, 1582, 3, 2, 2, 2, 287, 1587, 3, 2, 2, 2, 289, 1597, 3, 2, 2, 2, 291, 1607, 3, 2, 2, 2, 293, 1618, 3, 2, 2, 2, 295, 1626, 3, 2, 2, 2, 297, 1635, 3, 2, 2, 2, 299, 1645, 3, 2, 2, 2, 301, 1653, 3, 2, 2, 2, 303, 1665, 3, 2, 2, 2, 305, 1676, 3, 2, 2, 2, 307, 1687, 3, 2, 2, 2, 309, 1693, 3, 2, 2, 2, 311, 1701, 3, 2, 2, 2, 313, 1708, 3, 2, 2, 2, 315, 1719, 3, 2, 2, 2, 317, 1727, 3, 2, 2, 2, 319, 1736, 3, 2, 2, 2, 321, 1744, 3, 2, 2, 2, 323, 1751, 3, 2, 2, 2, 325, 1759, 3, 2, 2, 2, 327, 1766, 3, 2, 2, 2, 329, 1772, 3, 2, 2, 2, 331, 1778, 3, 2, 2, 2, 333, 1783, 3, 2, 2, 2, 335, 1789, 3, 2, 2, 2, 337, 1793, 3, 2, 2, 2, 339, 1798, 3, 2, 2, 2, 341, 1805, 3, 2, 2, 2, 343, 1813, 3, 2, 2, 2, 345, 1820, 3, 2, 2, 2, 347, 1828, 3, 2, 2, 2, 349, 1835, 3, 2, 2, 2, 351, 1851, 3, 2, 2, 2, 353, 1855, 3, 2, 2, 2, 355, 1860, 3, 2, 2, 2, 357, 1867, 3, 2, 2, 2, 359, 1872, 3, 2, 2, 2, 361, 1881, 3, 2, 2, 2, 363, 1886, 3, 2, 2, 2, 365, 1892, 3, 2, 2, 2, 367, 1899, 3, 2, 2, 2, 369, 1913, 3, 2, 2, 2, 371, 1923, 3, 2, 2, 2, 373, 1930, 3, 2, 2, 2, 375, 1937, 3, 2, 2, 2, 377, 1950, 3, 2, 2, 2, 379, 1956, 3, 2, 2, 2, 381, 1963, 3, 2, 2, 2, 383, 1975, 3, 2, 2, 2, 385, 1987, 3, 2, 2, 2, 387, 1992, 3, 2, 2, 2, 389, 1995, 3, 2, 2, 2, 391, 2000, 3, 2, 2, 2, 393, 2009, 3, 2, 2, 2, 395, 2018, 3, 2, 2, 2, 397, 2027, 3, 2, 2, 2, 399, 2035, 3, 2, 2, 2, 401, 2045, 3, 2, 2, 2, 403, 2051, 3, 2, 2, 2, 405, 2058, 3, 2, 2, 2, 407, 2064, 3, 2, 2, 2, 409, 2068, 3, 2, 2, 2, 411, 2073, 3, 2, 2, 2, 413, 2079, 3, 2, 2, 2, 415, 2089, 3, 2, 2, 2, 417, 2096, 3, 2, 2, 2, 419, 2100, 3, 2, 2, 2, 421, 2106, 3, 2, 2, 2, 423, 2113, 3, 2, 2, 2, 425, 2118, 3, 2, 2, 2, 427, 2124, 3, 2, 2, 2, 429, 2129, 3, 2, 2, 2, 431, 2135, 3, 2, 2, 2, 433, 2140, 3, 2, 2, 2, 435, 2145, 3, 2, 2, 2, 437, 2151, 3, 2, 2, 2, 439, 2160, 3, 2, 2, 2, 441, 2164, 3, 2, 2, 2, 443, 2169, 3, 2, 2, 2, 445, 2182, 3, 2, 2, 2, 447, 2189, 3, 2, 2, 2, 449, 2200, 3, 2, 2, 2, 451, 2211, 3, 2, 2, 2, 453, 2216, 3, 2, 2, 2, 455, 2225, 3, 2, 2, 2, 457, 2236, 3, 2, 2, 2, 459, 2246, 3, 2, 2, 2, 461, 2256, 3, 2, 2, 2, 463, 2262, 3, 2, 2, 2, 465, 2264, 3, 2, 2, 2, 467, 2266, 3, 2, 2, 2, 469, 2269, 3, 2, 2, 2, 471, 2271, 3, 2, 2, 2, 473, 2274, 3, 2, 2, 2, 475, 2276, 3, 2, 2, 2, 477, 2278, 3, 2, 2, 2, 479, 2280, 3, 2, 2, 2, 481, 2282, 3, 2, 2, 2, 483, 2284, 3, 2, 2, 2, 485, 2287, 3, 2, 2, 2, 487, 2289, 3, 2, 2, 2, 489, 2291, 3, 2, 2, 2, 491, 2293, 3, 2, 2, 2, 493, 2295, 3, 2, 2, 2, 495, 2297, 3, 2, 2, 2, 497, 2299, 3, 2, 2, 2, 499, 2301, 3, 2, 2, 2, 501, 2303, 3, 2, 2, 2, 503, 2305, 3, 2, 2, 2, 505, 2307, 3, 2, 2, 2, 507, 2309, 3, 2, 2, 2, 509, 2311, 3, 2, 2, 2, 511, 2334, 3, 2, 2, 2, 513, 2336, 3, 2, 2, 2, 515, 2350, 3, 2, 2, 2, 517, 2362, 3, 2, 2, 2, 519, 2384, 3, 2, 2, 2, 521, 2410, 3, 2, 2, 2, 523, 2414, 3, 2, 2, 2, 525, 2424, 3, 2, 2, 2, 527, 2432, 3, 2, 2, 2, 529, 2443, 3, 2, 2, 2, 531, 2454, 3, 2, 2, 2, 533, 2477, 3, 2, 2, 2, 535, 2505, 3, 2, 2, 2, 537, 2523, 3, 2, 2, 2, 539, 2532, 3, 2, 2, 2, 541, 2534, 3, 2, 2, 2, 543, 2536, 3, 2, 2, 2, 545, 2553, 3, 2, 2, 2, 547, 2568, 3, 2, 2, 2, 549, 550, 7, 67, 2, 2, 550, 551, 7, 70, 2, 2, 551, 552, 7, 70, 2, 2, 552, 4, 3, 2, 2, 2, 553, 554, 7, 67, 2, 2, 554, 555, 7, 78, 2, 2, 555, 556, 7, 78, 2, 2, 556, 6, 3, 2, 2, 2, 557, 558, 7, 67, 2, 2, 558, 559, 7, 80, 2, 2, 559, 560, 7, 67, 2, 2, 560, 561, 7, 78, 2, 2, 561, 562, 7, 91, 2, 2, 562, 563, 7, 86, 2, 2, 563, 564, 7, 75, 2, 2, 564, 565, 7, 69, 2, 2, 565, 8, 3, 2, 2, 2, 566, 567, 7, 67, 2, 2, 567, 568, 7, 78, 2, 2, 568, 569, 7, 86, 2, 2, 569, 570, 7, 71, 2, 2, 570, 571, 7, 84, 2, 2, 571, 10, 3, 2, 2, 2, 572, 573, 7, 67, 2, 2, 573, 574, 7, 80, 2, 2, 574, 575, 7, 70, 2, 2, 575, 12, 3, 2, 2, 2, 576, 577, 7, 67, 2, 2, 577, 578, 7, 80, 2, 2, 578, 579, 7, 91, 2, 2, 579, 14, 3, 2, 2, 2, 580, 581, 7, 67, 2, 2, 581, 582, 7, 80, 2, 2, 582, 583, 7, 86, 2, 2, 583, 584, 7, 75, 2, 2, 584, 16, 3, 2, 2, 2, 585, 586, 7, 67, 2, 2, 586, 587, 7, 84, 2, 2, 587, 588, 7, 84, 2, 2, 588, 589, 7, 67, 2, 2, 589, 590, 7, 91, 2, 2, 590, 18, 3, 2, 2, 2, 591, 592, 7, 67, 2, 2, 592, 593, 7, 85, 2, 2, 593, 20, 3, 2, 2, 2, 594, 595, 7, 67, 2, 2, 595, 596, 7, 85, 2, 2, 596, 597, 7, 69, 2, 2, 597, 22, 3, 2, 2, 2, 598, 599, 7, 67, 2, 2, 599, 600, 7, 86, 2, 2, 600, 24, 3, 2, 2, 2, 601, 602, 7, 67, 2, 2, 602, 603, 7, 73, 2, 2, 603, 604, 7, 73, 2, 2, 604, 605, 7, 84, 2, 2, 605, 606, 7, 71, 2, 2, 606, 607, 7, 73, 2, 2, 607, 608, 7, 67, 2, 2, 608, 609, 7, 86, 2, 2, 609, 610, 7, 71, 2, 2, 610, 26, 3, 2, 2, 2, 611, 612, 7, 67, 2, 2, 612, 613, 7, 87, 2, 2, 613, 614, 7, 86, 2, 2, 614, 615, 7, 74, 2, 2, 615, 616, 7, 81, 2, 2, 616, 617, 7, 84, 2, 2, 617, 618, 7, 75, 2, 2, 618, 619, 7, 92, 2, 2, 619, 620, 7, 67, 2, 2, 620, 621, 7, 86, 2, 2, 621, 622, 7, 75, 2, 2, 622, 623, 7, 81, 2, 2, 623, 624, 7, 80, 2, 2, 624, 28, 3, 2, 2, 2, 625, 626, 7, 68, 2, 2, 626, 627, 7, 71, 2, 2, 627, 628, 7, 84, 2, 2, 628, 629, 7, 80, 2, 2, 629, 630, 7, 81, 2, 2, 630, 631, 7, 87, 2, 2, 631, 632, 7, 78, 2, 2, 632, 633, 7, 78, 2, 2, 633, 634, 7, 75, 2, 2, 634, 30, 3, 2, 2, 2, 635, 636, 7, 68, 2, 2, 636, 637, 7, 71, 2, 2, 637, 638, 7, 86, 2, 2, 638, 639, 7, 89, 2, 2, 639, 640, 7, 71, 2, 2, 640, 641, 7, 71, 2, 2, 641, 642, 7, 80, 2, 2, 642, 32, 3, 2, 2, 2, 643, 644, 7, 68, 2, 2, 644, 645, 7, 78, 2, 2, 645, 646, 7, 81, 2, 2, 646, 647, 7, 69, 2, 2, 647, 648, 7, 77, 2, 2, 648, 649, 7, 97, 2, 2, 649, 650, 7, 85, 2, 2, 650, 651, 7, 75, 2, 2, 651, 652, 7, 92, 2, 2, 652, 653, 7, 71, 2, 2, 653, 34, 3, 2, 2, 2, 654, 655, 7, 82, 2, 2, 655, 656, 7, 67, 2, 2, 656, 657, 7, 84, 2, 2, 657, 658, 7, 86, 2, 2, 658, 659, 7, 75, 2, 2, 659, 660, 7, 86, 2, 2, 660, 661, 7, 75, 2, 2, 661, 662, 7, 81, 2, 2, 662, 663, 7, 80, 2, 2, 663, 664, 7, 71, 2, 2, 664, 665, 7, 70, 2, 2, 665, 36, 3, 2, 2, 2, 666, 667, 7, 82, 2, 2, 667, 668, 7, 84, 2, 2, 668, 669, 7, 71, 2, 2, 669, 670, 7, 82, 2, 2, 670, 671, 7, 67, 2, 2, 671, 672, 7, 84, 2, 2, 672, 673, 7, 71, 2, 2, 673, 674, 7, 97, 2, 2, 674, 675, 7, 72, 2, 2, 675, 676, 7, 80, 2, 2, 676, 38, 3, 2, 2, 2, 677, 678, 7, 71, 2, 2, 678, 679, 7, 90, 2, 2, 679, 680, 7, 86, 2, 2, 680, 681, 7, 71, 2, 2, 681, 682, 7, 84, 2, 2, 682, 683, 7, 80, 2, 2, 683, 684, 7, 67, 2, 2, 684, 685, 7, 78, 2, 2, 685, 40, 3, 2, 2, 2, 686, 687, 7, 69, 2, 2, 687, 688, 7, 78, 2, 2, 688, 689, 7, 81, 2, 2, 689, 690, 7, 85, 2, 2, 690, 691, 7, 71, 2, 2, 691, 692, 7, 72, 2, 2, 692, 693, 7, 80, 2, 2, 693, 42, 3, 2, 2, 2, 694, 695, 7, 85, 2, 2, 695, 696, 7, 81, 2, 2, 696, 697, 7, 84, 2, 2, 697, 698, 7, 86, 2, 2, 698, 44, 3, 2, 2, 2, 699, 700, 7, 82, 2, 2, 700, 701, 7, 87, 2, 2, 701, 702, 7, 84, 2, 2, 702, 703, 7, 73, 2, 2, 703, 704, 7, 71, 2, 2, 704, 46, 3, 2, 2, 2, 705, 706, 7, 85, 2, 2, 706, 707, 7, 86, 2, 2, 707, 708, 7, 81, 2, 2, 708, 709, 7, 84, 2, 2, 709, 710, 7, 71, 2, 2, 710, 711, 7, 70, 2, 2, 711, 48, 3, 2, 2, 2, 712, 713, 7, 78, 2, 2, 713, 714, 7, 81, 2, 2, 714, 715, 7, 69, 2, 2, 715, 716, 7, 67, 2, 2, 716, 717, 7, 86, 2, 2, 717, 718, 7, 75, 2, 2, 718, 719, 7, 81, 2, 2, 719, 720, 7, 80, 2, 2, 720, 50, 3, 2, 2, 2, 721, 722, 7, 86, 2, 2, 722, 723, 7, 68, 2, 2, 723, 724, 7, 78, 2, 2, 724, 725, 7, 82, 2, 2, 725, 726, 7, 84, 2, 2, 726, 727, 7, 81, 2, 2, 727, 728, 7, 82, 2, 2, 728, 729, 7, 71, 2, 2, 729, 730, 7, 84, 2, 2, 730, 731, 7, 86, 2, 2, 731, 732, 7, 75, 2, 2, 732, 733, 7, 71, 2, 2, 733, 734, 7, 85, 2, 2, 734, 52, 3, 2, 2, 2, 735, 736, 7, 68, 2, 2, 736, 737, 7, 91, 2, 2, 737, 54, 3, 2, 2, 2, 738, 739, 7, 69, 2, 2, 739, 740, 7, 67, 2, 2, 740, 741, 7, 85, 2, 2, 741, 742, 7, 69, 2, 2, 742, 743, 7, 67, 2, 2, 743, 744, 7, 70, 2, 2, 744, 745, 7, 71, 2, 2, 745, 56, 3, 2, 2, 2, 746, 747, 7, 69, 2, 2, 747, 748, 7, 67, 2, 2, 748, 749, 7, 85, 2, 2, 749, 750, 7, 71, 2, 2, 750, 58, 3, 2, 2, 2, 751, 752, 7, 69, 2, 2, 752, 753, 7, 67, 2, 2, 753, 754, 7, 85, 2, 2, 754, 755, 7, 86, 2, 2, 755, 60, 3, 2, 2, 2, 756, 757, 7, 69, 2, 2, 757, 758, 7, 67, 2, 2, 758, 759, 7, 69, 2, 2, 759, 760, 7, 74, 2, 2, 760, 761, 7, 71, 2, 2, 761, 762, 7, 70, 2, 2, 762, 62, 3, 2, 2, 2, 763, 764, 7, 69, 2, 2, 764, 765, 7, 74, 2, 2, 765, 766, 7, 67, 2, 2, 766, 767, 7, 80, 2, 2, 767, 768, 7, 73, 2, 2, 768, 769, 7, 71, 2, 2, 769, 64, 3, 2, 2, 2, 770, 771, 7, 69, 2, 2, 771, 772, 7, 81, 2, 2, 772, 773, 7, 78, 2, 2, 773, 774, 7, 87, 2, 2, 774, 775, 7, 79, 2, 2, 775, 776, 7, 80, 2, 2, 776, 66, 3, 2, 2, 2, 777, 778, 7, 69, 2, 2, 778, 779, 7, 81, 2, 2, 779, 780, 7, 78, 2, 2, 780, 781, 7, 87, 2, 2, 781, 782, 7, 79, 2, 2, 782, 783, 7, 80, 2, 2, 783, 784, 7, 85, 2, 2, 784, 68, 3, 2, 2, 2, 785, 786, 7, 69, 2, 2, 786, 787, 7, 81, 2, 2, 787, 788, 7, 79, 2, 2, 788, 789, 7, 79, 2, 2, 789, 790, 7, 71, 2, 2, 790, 791, 7, 80, 2, 2, 791, 792, 7, 86, 2, 2, 792, 70, 3, 2, 2, 2, 793, 794, 7, 69, 2, 2, 794, 795, 7, 81, 2, 2, 795, 796, 7, 79, 2, 2, 796, 797, 7, 82, 2, 2, 797, 798, 7, 84, 2, 2, 798, 799, 7, 71, 2, 2, 799, 800, 7, 85, 2, 2, 800, 801, 7, 85, 2, 2, 801, 802, 7, 75, 2, 2, 802, 803, 7, 81, 2, 2, 803, 804, 7, 80, 2, 2, 804, 72, 3, 2, 2, 2, 805, 806, 7, 69, 2, 2, 806, 807, 7, 81, 2, 2, 807, 808, 7, 79, 2, 2, 808, 809, 7, 82, 2, 2, 809, 810, 7, 87, 2, 2, 810, 811, 7, 86, 2, 2, 811, 812, 7, 71, 2, 2, 812, 74, 3, 2, 2, 2, 813, 814, 7, 69, 2, 2, 814, 815, 7, 84, 2, 2, 815, 816, 7, 71, 2, 2, 816, 817, 7, 67, 2, 2, 817, 818, 7, 86, 2, 2, 818, 819, 7, 71, 2, 2, 819, 76, 3, 2, 2, 2, 820, 821, 7, 69, 2, 2, 821, 822, 7, 84, 2, 2, 822, 823, 7, 81, 2, 2, 823, 824, 7, 85, 2, 2, 824, 825, 7, 85, 2, 2, 825, 78, 3, 2, 2, 2, 826, 827, 7, 69, 2, 2, 827, 828, 7, 87, 2, 2, 828, 829, 7, 84, 2, 2, 829, 830, 7, 84, 2, 2, 830, 831, 7, 71, 2, 2, 831, 832, 7, 80, 2, 2, 832, 833, 7, 86, 2, 2, 833, 80, 3, 2, 2, 2, 834, 835, 7, 69, 2, 2, 835, 836, 7, 87, 2, 2, 836, 837, 7, 84, 2, 2, 837, 838, 7, 84, 2, 2, 838, 839, 7, 71, 2, 2, 839, 840, 7, 80, 2, 2, 840, 841, 7, 86, 2, 2, 841, 842, 7, 97, 2, 2, 842, 843, 7, 70, 2, 2, 843, 844, 7, 67, 2, 2, 844, 845, 7, 86, 2, 2, 845, 846, 7, 71, 2, 2, 846, 82, 3, 2, 2, 2, 847, 848, 7, 69, 2, 2, 848, 849, 7, 87, 2, 2, 849, 850, 7, 84, 2, 2, 850, 851, 7, 84, 2, 2, 851, 852, 7, 71, 2, 2, 852, 853, 7, 80, 2, 2, 853, 854, 7, 86, 2, 2, 854, 855, 7, 97, 2, 2, 855, 856, 7, 82, 2, 2, 856, 857, 7, 67, 2, 2, 857, 858, 7, 86, 2, 2, 858, 859, 7, 74, 2, 2, 859, 84, 3, 2, 2, 2, 860, 861, 7, 69, 2, 2, 861, 862, 7, 87, 2, 2, 862, 863, 7, 84, 2, 2, 863, 864, 7, 84, 2, 2, 864, 865, 7, 71, 2, 2, 865, 866, 7, 80, 2, 2, 866, 867, 7, 86, 2, 2, 867, 868, 7, 97, 2, 2, 868, 869, 7, 86, 2, 2, 869, 870, 7, 75, 2, 2, 870, 871, 7, 79, 2, 2, 871, 872, 7, 71, 2, 2, 872, 86, 3, 2, 2, 2, 873, 874, 7, 69, 2, 2, 874, 875, 7, 87, 2, 2, 875, 876, 7, 84, 2, 2, 876, 877, 7, 84, 2, 2, 877, 878, 7, 71, 2, 2, 878, 879, 7, 80, 2, 2, 879, 880, 7, 86, 2, 2, 880, 881, 7, 97, 2, 2, 881, 882, 7, 86, 2, 2, 882, 883, 7, 75, 2, 2, 883, 884, 7, 79, 2, 2, 884, 885, 7, 71, 2, 2, 885, 886, 7, 85, 2, 2, 886, 887, 7, 86, 2, 2, 887, 888, 7, 67, 2, 2, 888, 889, 7, 79, 2, 2, 889, 890, 7, 82, 2, 2, 890, 88, 3, 2, 2, 2, 891, 892, 7, 69, 2, 2, 892, 893, 7, 87, 2, 2, 893, 894, 7, 84, 2, 2, 894, 895, 7, 84, 2, 2, 895, 896, 7, 71, 2, 2, 896, 897, 7, 80, 2, 2, 897, 898, 7, 86, 2, 2, 898, 899, 7, 97, 2, 2, 899, 900, 7, 87, 2, 2, 900, 901, 7, 85, 2, 2, 901, 902, 7, 71, 2, 2, 902, 903, 7, 84, 2, 2, 903, 90, 3, 2, 2, 2, 904, 905, 7, 70, 2, 2, 905, 906, 7, 67, 2, 2, 906, 907, 7, 86, 2, 2, 907, 908, 7, 67, 2, 2, 908, 92, 3, 2, 2, 2, 909, 910, 7, 70, 2, 2, 910, 911, 7, 67, 2, 2, 911, 912, 7, 86, 2, 2, 912, 913, 7, 67, 2, 2, 913, 914, 7, 68, 2, 2, 914, 915, 7, 67, 2, 2, 915, 916, 7, 85, 2, 2, 916, 917, 7, 71, 2, 2, 917, 94, 3, 2, 2, 2, 918, 919, 7, 70, 2, 2, 919, 920, 7, 67, 2, 2, 920, 921, 7, 86, 2, 2, 921, 922, 7, 67, 2, 2, 922, 923, 7, 68, 2, 2, 923, 924, 7, 67, 2, 2, 924, 925, 7, 85, 2, 2, 925, 926, 7, 71, 2, 2, 926, 927, 7, 85, 2, 2, 927, 96, 3, 2, 2, 2, 928, 929, 7, 70, 2, 2, 929, 930, 7, 67, 2, 2, 930, 931, 7, 91, 2, 2, 931, 98, 3, 2, 2, 2, 932, 933, 7, 70, 2, 2, 933, 934, 7, 67, 2, 2, 934, 935, 7, 91, 2, 2, 935, 936, 7, 85, 2, 2, 936, 100, 3, 2, 2, 2, 937, 938, 7, 70, 2, 2, 938, 939, 7, 71, 2, 2, 939, 940, 7, 78, 2, 2, 940, 941, 7, 71, 2, 2, 941, 942, 7, 86, 2, 2, 942, 943, 7, 71, 2, 2, 943, 102, 3, 2, 2, 2, 944, 945, 7, 70, 2, 2, 945, 946, 7, 71, 2, 2, 946, 947, 7, 72, 2, 2, 947, 948, 7, 67, 2, 2, 948, 949, 7, 87, 2, 2, 949, 950, 7, 78, 2, 2, 950, 951, 7, 86, 2, 2, 951, 104, 3, 2, 2, 2, 952, 953, 7, 70, 2, 2, 953, 954, 7, 71, 2, 2, 954, 955, 7, 78, 2, 2, 955, 956, 7, 75, 2, 2, 956, 957, 7, 79, 2, 2, 957, 958, 7, 75, 2, 2, 958, 959, 7, 86, 2, 2, 959, 960, 7, 71, 2, 2, 960, 961, 7, 70, 2, 2, 961, 106, 3, 2, 2, 2, 962, 963, 7, 70, 2, 2, 963, 964, 7, 75, 2, 2, 964, 965, 7, 85, 2, 2, 965, 966, 7, 67, 2, 2, 966, 967, 7, 68, 2, 2, 967, 968, 7, 78, 2, 2, 968, 969, 7, 71, 2, 2, 969, 108, 3, 2, 2, 2, 970, 971, 7, 87, 2, 2, 971, 972, 7, 82, 2, 2, 972, 973, 7, 70, 2, 2, 973, 974, 7, 67, 2, 2, 974, 975, 7, 86, 2, 2, 975, 976, 7, 71, 2, 2, 976, 110, 3, 2, 2, 2, 977, 978, 7, 70, 2, 2, 978, 979, 7, 71, 2, 2, 979, 980, 7, 85, 2, 2, 980, 981, 7, 69, 2, 2, 981, 112, 3, 2, 2, 2, 982, 983, 7, 70, 2, 2, 983, 984, 7, 71, 2, 2, 984, 985, 7, 85, 2, 2, 985, 986, 7, 69, 2, 2, 986, 987, 7, 84, 2, 2, 987, 988, 7, 75, 2, 2, 988, 989, 7, 68, 2, 2, 989, 990, 7, 71, 2, 2, 990, 114, 3, 2, 2, 2, 991, 992, 7, 70, 2, 2, 992, 993, 7, 75, 2, 2, 993, 994, 7, 85, 2, 2, 994, 995, 7, 86, 2, 2, 995, 996, 7, 75, 2, 2, 996, 997, 7, 80, 2, 2, 997, 998, 7, 69, 2, 2, 998, 999, 7, 86, 2, 2, 999, 116, 3, 2, 2, 2, 1000, 1001, 7, 70, 2, 2, 1001, 1002, 7, 84, 2, 2, 1002, 1003, 7, 81, 2, 2, 1003, 1004, 7, 82, 2, 2, 1004, 118, 3, 2, 2, 2, 1005, 1006, 7, 71, 2, 2, 1006, 1007, 7, 78, 2, 2, 1007, 1008, 7, 85, 2, 2, 1008, 1009, 7, 71, 2, 2, 1009, 120, 3, 2, 2, 2, 1010, 1011, 7, 71, 2, 2, 1011, 1012, 7, 80, 2, 2, 1012, 1013, 7, 69, 2, 2, 1013, 1014, 7, 81, 2, 2, 1014, 1015, 7, 70, 2, 2, 1015, 1016, 7, 75, 2, 2, 1016, 1017, 7, 80, 2, 2, 1017, 1018, 7, 73, 2, 2, 1018, 122, 3, 2, 2, 2, 1019, 1020, 7, 71, 2, 2, 1020, 1021, 7, 80, 2, 2, 1021, 1022, 7, 70, 2, 2, 1022, 124, 3, 2, 2, 2, 1023, 1024, 7, 71, 2, 2, 1024, 1025, 7, 85, 2, 2, 1025, 1026, 7, 69, 2, 2, 1026, 1027, 7, 67, 2, 2, 1027, 1028, 7, 82, 2, 2, 1028, 1029, 7, 71, 2, 2, 1029, 126, 3, 2, 2, 2, 1030, 1031, 7, 71, 2, 2, 1031, 1032, 7, 85, 2, 2, 1032, 1033, 7, 69, 2, 2, 1033, 1034, 7, 67, 2, 2, 1034, 1035, 7, 82, 2, 2, 1035, 1036, 7, 71, 2, 2, 1036, 1037, 7, 70, 2, 2, 1037, 128, 3, 2, 2, 2, 1038, 1039, 7, 71, 2, 2, 1039, 1040, 7, 90, 2, 2, 1040, 1041, 7, 69, 2, 2, 1041, 1042, 7, 71, 2, 2, 1042, 1043, 7, 82, 2, 2, 1043, 1044, 7, 86, 2, 2, 1044, 130, 3, 2, 2, 2, 1045, 1046, 7, 71, 2, 2, 1046, 1047, 7, 90, 2, 2, 1047, 1048, 7, 69, 2, 2, 1048, 1049, 7, 78, 2, 2, 1049, 1050, 7, 87, 2, 2, 1050, 1051, 7, 70, 2, 2, 1051, 1052, 7, 75, 2, 2, 1052, 1053, 7, 80, 2, 2, 1053, 1054, 7, 73, 2, 2, 1054, 132, 3, 2, 2, 2, 1055, 1056, 7, 71, 2, 2, 1056, 1057, 7, 90, 2, 2, 1057, 1058, 7, 75, 2, 2, 1058, 1059, 7, 85, 2, 2, 1059, 1060, 7, 86, 2, 2, 1060, 1061, 7, 85, 2, 2, 1061, 134, 3, 2, 2, 2, 1062, 1063, 7, 71, 2, 2, 1063, 1064, 7, 90, 2, 2, 1064, 1065, 7, 82, 2, 2, 1065, 1066, 7, 78, 2, 2, 1066, 1067, 7, 67, 2, 2, 1067, 1068, 7, 75, 2, 2, 1068, 1069, 7, 80, 2, 2, 1069, 136, 3, 2, 2, 2, 1070, 1071, 7, 71, 2, 2, 1071, 1072, 7, 90, 2, 2, 1072, 1073, 7, 86, 2, 2, 1073, 1074, 7, 84, 2, 2, 1074, 1075, 7, 67, 2, 2, 1075, 1076, 7, 69, 2, 2, 1076, 1077, 7, 86, 2, 2, 1077, 138, 3, 2, 2, 2, 1078, 1079, 7, 71, 2, 2, 1079, 1080, 7, 90, 2, 2, 1080, 1081, 7, 86, 2, 2, 1081, 1082, 7, 71, 2, 2, 1082, 1083, 7, 80, 2, 2, 1083, 1084, 7, 70, 2, 2, 1084, 1085, 7, 71, 2, 2, 1085, 1086, 7, 70, 2, 2, 1086, 140, 3, 2, 2, 2, 1087, 1088, 7, 72, 2, 2, 1088, 1089, 7, 67, 2, 2, 1089, 1090, 7, 78, 2, 2, 1090, 1091, 7, 85, 2, 2, 1091, 1092, 7, 71, 2, 2, 1092, 142, 3, 2, 2, 2, 1093, 1094, 7, 72, 2, 2, 1094, 1095, 7, 75, 2, 2, 1095, 1096, 7, 71, 2, 2, 1096, 1097, 7, 78, 2, 2, 1097, 1098, 7, 70, 2, 2, 1098, 1099, 7, 85, 2, 2, 1099, 144, 3, 2, 2, 2, 1100, 1101, 7, 72, 2, 2, 1101, 1102, 7, 75, 2, 2, 1102, 1103, 7, 78, 2, 2, 1103, 1104, 7, 71, 2, 2, 1104, 1105, 7, 72, 2, 2, 1105, 1106, 7, 81, 2, 2, 1106, 1107, 7, 84, 2, 2, 1107, 1108, 7, 79, 2, 2, 1108, 1109, 7, 67, 2, 2, 1109, 1110, 7, 86, 2, 2, 1110, 146, 3, 2, 2, 2, 1111, 1112, 7, 72, 2, 2, 1112, 1113, 7, 75, 2, 2, 1113, 1114, 7, 78, 2, 2, 1114, 1115, 7, 71, 2, 2, 1115, 1116, 7, 85, 2, 2, 1116, 148, 3, 2, 2, 2, 1117, 1118, 7, 72, 2, 2, 1118, 1119, 7, 75, 2, 2, 1119, 1120, 7, 78, 2, 2, 1120, 1121, 7, 86, 2, 2, 1121, 1122, 7, 71, 2, 2, 1122, 1123, 7, 84, 2, 2, 1123, 150, 3, 2, 2, 2, 1124, 1125, 7, 72, 2, 2, 1125, 1126, 7, 75, 2, 2, 1126, 1127, 7, 84, 2, 2, 1127, 1128, 7, 85, 2, 2, 1128, 1129, 7, 86, 2, 2, 1129, 152, 3, 2, 2, 2, 1130, 1131, 7, 72, 2, 2, 1131, 1132, 7, 75, 2, 2, 1132, 1133, 7, 80, 2, 2, 1133, 1134, 7, 67, 2, 2, 1134, 1135, 7, 78, 2, 2, 1135, 1136, 7, 75, 2, 2, 1136, 1137, 7, 92, 2, 2, 1137, 1138, 7, 71, 2, 2, 1138, 1139, 7, 97, 2, 2, 1139, 1140, 7, 72, 2, 2, 1140, 1141, 7, 80, 2, 2, 1141, 154, 3, 2, 2, 2, 1142, 1143, 7, 72, 2, 2, 1143, 1144, 7, 81, 2, 2, 1144, 1145, 7, 78, 2, 2, 1145, 1146, 7, 78, 2, 2, 1146, 1147, 7, 81, 2, 2, 1147, 1148, 7, 89, 2, 2, 1148, 1149, 7, 75, 2, 2, 1149, 1150, 7, 80, 2, 2, 1150, 1151, 7, 73, 2, 2, 1151, 156, 3, 2, 2, 2, 1152, 1153, 7, 72, 2, 2, 1153, 1154, 7, 81, 2, 2, 1154, 1155, 7, 84, 2, 2, 1155, 158, 3, 2, 2, 2, 1156, 1157, 7, 72, 2, 2, 1157, 1158, 7, 81, 2, 2, 1158, 1159, 7, 84, 2, 2, 1159, 1160, 7, 79, 2, 2, 1160, 1161, 7, 67, 2, 2, 1161, 1162, 7, 86, 2, 2, 1162, 160, 3, 2, 2, 2, 1163, 1164, 7, 72, 2, 2, 1164, 1165, 7, 81, 2, 2, 1165, 1166, 7, 84, 2, 2, 1166, 1167, 7, 79, 2, 2, 1167, 1168, 7, 67, 2, 2, 1168, 1169, 7, 86, 2, 2, 1169, 1170, 7, 86, 2, 2, 1170, 1171, 7, 71, 2, 2, 1171, 1172, 7, 70, 2, 2, 1172, 162, 3, 2, 2, 2, 1173, 1174, 7, 72, 2, 2, 1174, 1175, 7, 81, 2, 2, 1175, 1176, 7, 84, 2, 2, 1176, 1177, 7, 71, 2, 2, 1177, 1178, 7, 75, 2, 2, 1178, 1179, 7, 73, 2, 2, 1179, 1180, 7, 80, 2, 2, 1180, 164, 3, 2, 2, 2, 1181, 1182, 7, 72, 2, 2, 1182, 1183, 7, 84, 2, 2, 1183, 1184, 7, 81, 2, 2, 1184, 1185, 7, 79, 2, 2, 1185, 166, 3, 2, 2, 2, 1186, 1187, 7, 72, 2, 2, 1187, 1188, 7, 87, 2, 2, 1188, 1189, 7, 78, 2, 2, 1189, 1190, 7, 78, 2, 2, 1190, 168, 3, 2, 2, 2, 1191, 1192, 7, 72, 2, 2, 1192, 1193, 7, 87, 2, 2, 1193, 1194, 7, 80, 2, 2, 1194, 1195, 7, 69, 2, 2, 1195, 1196, 7, 86, 2, 2, 1196, 1197, 7, 75, 2, 2, 1197, 1198, 7, 81, 2, 2, 1198, 1199, 7, 80, 2, 2, 1199, 170, 3, 2, 2, 2, 1200, 1201, 7, 72, 2, 2, 1201, 1202, 7, 87, 2, 2, 1202, 1203, 7, 80, 2, 2, 1203, 1204, 7, 69, 2, 2, 1204, 1205, 7, 86, 2, 2, 1205, 1206, 7, 75, 2, 2, 1206, 1207, 7, 81, 2, 2, 1207, 1208, 7, 80, 2, 2, 1208, 1209, 7, 85, 2, 2, 1209, 172, 3, 2, 2, 2, 1210, 1211, 7, 73, 2, 2, 1211, 1212, 7, 84, 2, 2, 1212, 1213, 7, 67, 2, 2, 1213, 1214, 7, 80, 2, 2, 1214, 1215, 7, 86, 2, 2, 1215, 174, 3, 2, 2, 2, 1216, 1217, 7, 73, 2, 2, 1217, 1218, 7, 84, 2, 2, 1218, 1219, 7, 81, 2, 2, 1219, 1220, 7, 87, 2, 2, 1220, 1221, 7, 82, 2, 2, 1221, 176, 3, 2, 2, 2, 1222, 1223, 7, 73, 2, 2, 1223, 1224, 7, 84, 2, 2, 1224, 1225, 7, 81, 2, 2, 1225, 1226, 7, 87, 2, 2, 1226, 1227, 7, 82, 2, 2, 1227, 1228, 7, 75, 2, 2, 1228, 1229, 7, 80, 2, 2, 1229, 1230, 7, 73, 2, 2, 1230, 178, 3, 2, 2, 2, 1231, 1232, 7, 74, 2, 2, 1232, 1233, 7, 67, 2, 2, 1233, 1234, 7, 85, 2, 2, 1234, 1235, 7, 74, 2, 2, 1235, 180, 3, 2, 2, 2, 1236, 1237, 7, 74, 2, 2, 1237, 1238, 7, 67, 2, 2, 1238, 1239, 7, 88, 2, 2, 1239, 1240, 7, 75, 2, 2, 1240, 1241, 7, 80, 2, 2, 1241, 1242, 7, 73, 2, 2, 1242, 182, 3, 2, 2, 2, 1243, 1244, 7, 74, 2, 2, 1244, 1245, 7, 81, 2, 2, 1245, 1246, 7, 87, 2, 2, 1246, 1247, 7, 84, 2, 2, 1247, 184, 3, 2, 2, 2, 1248, 1249, 7, 74, 2, 2, 1249, 1250, 7, 81, 2, 2, 1250, 1251, 7, 87, 2, 2, 1251, 1252, 7, 84, 2, 2, 1252, 1253, 7, 85, 2, 2, 1253, 186, 3, 2, 2, 2, 1254, 1255, 7, 75, 2, 2, 1255, 1256, 7, 72, 2, 2, 1256, 188, 3, 2, 2, 2, 1257, 1258, 7, 75, 2, 2, 1258, 1259, 7, 80, 2, 2, 1259, 190, 3, 2, 2, 2, 1260, 1261, 7, 75, 2, 2, 1261, 1262, 7, 80, 2, 2, 1262, 1263, 7, 69, 2, 2, 1263, 1264, 7, 78, 2, 2, 1264, 1265, 7, 87, 2, 2, 1265, 1266, 7, 70, 2, 2, 1266, 1267, 7, 75, 2, 2, 1267, 1268, 7, 80, 2, 2, 1268, 1269, 7, 73, 2, 2, 1269, 192, 3, 2, 2, 2, 1270, 1271, 7, 75, 2, 2, 1271, 1272, 7, 80, 2, 2, 1272, 1273, 7, 69, 2, 2, 1273, 1274, 7, 84, 2, 2, 1274, 1275, 7, 71, 2, 2, 1275, 1276, 7, 79, 2, 2, 1276, 1277, 7, 71, 2, 2, 1277, 1278, 7, 80, 2, 2, 1278, 1279, 7, 86, 2, 2, 1279, 1280, 7, 67, 2, 2, 1280, 1281, 7, 78, 2, 2, 1281, 194, 3, 2, 2, 2, 1282, 1283, 7, 75, 2, 2, 1283, 1284, 7, 80, 2, 2, 1284, 1285, 7, 80, 2, 2, 1285, 1286, 7, 71, 2, 2, 1286, 1287, 7, 84, 2, 2, 1287, 196, 3, 2, 2, 2, 1288, 1289, 7, 75, 2, 2, 1289, 1290, 7, 80, 2, 2, 1290, 1291, 7, 82, 2, 2, 1291, 1292, 7, 67, 2, 2, 1292, 1293, 7, 86, 2, 2, 1293, 1294, 7, 74, 2, 2, 1294, 198, 3, 2, 2, 2, 1295, 1296, 7, 75, 2, 2, 1296, 1297, 7, 80, 2, 2, 1297, 1298, 7, 85, 2, 2, 1298, 1299, 7, 71, 2, 2, 1299, 1300, 7, 84, 2, 2, 1300, 1301, 7, 86, 2, 2, 1301, 200, 3, 2, 2, 2, 1302, 1303, 7, 75, 2, 2, 1303, 1304, 7, 80, 2, 2, 1304, 1305, 7, 86, 2, 2, 1305, 1306, 7, 71, 2, 2, 1306, 1307, 7, 84, 2, 2, 1307, 1308, 7, 85, 2, 2, 1308, 1309, 7, 71, 2, 2, 1309, 1310, 7, 69, 2, 2, 1310, 1311, 7, 86, 2, 2, 1311, 202, 3, 2, 2, 2, 1312, 1313, 7, 75, 2, 2, 1313, 1314, 7, 80, 2, 2, 1314, 1315, 7, 86, 2, 2, 1315, 1316, 7, 71, 2, 2, 1316, 1317, 7, 84, 2, 2, 1317, 1318, 7, 88, 2, 2, 1318, 1319, 7, 67, 2, 2, 1319, 1320, 7, 78, 2, 2, 1320, 204, 3, 2, 2, 2, 1321, 1322, 7, 75, 2, 2, 1322, 1323, 7, 80, 2, 2, 1323, 1324, 7, 86, 2, 2, 1324, 1325, 7, 71, 2, 2, 1325, 1326, 7, 84, 2, 2, 1326, 1327, 7, 79, 2, 2, 1327, 1328, 7, 71, 2, 2, 1328, 1329, 7, 70, 2, 2, 1329, 1330, 7, 75, 2, 2, 1330, 1331, 7, 67, 2, 2, 1331, 1332, 7, 86, 2, 2, 1332, 1333, 7, 71, 2, 2, 1333, 206, 3, 2, 2, 2, 1334, 1335, 7, 75, 2, 2, 1335, 1336, 7, 80, 2, 2, 1336, 1337, 7, 86, 2, 2, 1337, 1338, 7, 81, 2, 2, 1338, 208, 3, 2, 2, 2, 1339, 1340, 7, 75, 2, 2, 1340, 1341, 7, 80, 2, 2, 1341, 1342, 7, 75, 2, 2, 1342, 1343, 7, 86, 2, 2, 1343, 1344, 7, 97, 2, 2, 1344, 1345, 7, 72, 2, 2, 1345, 1346, 7, 80, 2, 2, 1346, 210, 3, 2, 2, 2, 1347, 1348, 7, 75, 2, 2, 1348, 1349, 7, 80, 2, 2, 1349, 1350, 7, 88, 2, 2, 1350, 1351, 7, 67, 2, 2, 1351, 1352, 7, 78, 2, 2, 1352, 1353, 7, 75, 2, 2, 1353, 1354, 7, 70, 2, 2, 1354, 1355, 7, 67, 2, 2, 1355, 1356, 7, 86, 2, 2, 1356, 1357, 7, 71, 2, 2, 1357, 212, 3, 2, 2, 2, 1358, 1359, 7, 75, 2, 2, 1359, 1360, 7, 85, 2, 2, 1360, 214, 3, 2, 2, 2, 1361, 1362, 7, 76, 2, 2, 1362, 1363, 7, 81, 2, 2, 1363, 1364, 7, 75, 2, 2, 1364, 1365, 7, 80, 2, 2, 1365, 216, 3, 2, 2, 2, 1366, 1367, 7, 77, 2, 2, 1367, 1368, 7, 71, 2, 2, 1368, 1369, 7, 91, 2, 2, 1369, 218, 3, 2, 2, 2, 1370, 1371, 7, 77, 2, 2, 1371, 1372, 7, 87, 2, 2, 1372, 1373, 7, 70, 2, 2, 1373, 1374, 7, 87, 2, 2, 1374, 220, 3, 2, 2, 2, 1375, 1376, 7, 78, 2, 2, 1376, 1377, 7, 67, 2, 2, 1377, 1378, 7, 85, 2, 2, 1378, 1379, 7, 86, 2, 2, 1379, 222, 3, 2, 2, 2, 1380, 1381, 7, 78, 2, 2, 1381, 1382, 7, 67, 2, 2, 1382, 1383, 7, 86, 2, 2, 1383, 1384, 7, 71, 2, 2, 1384, 1385, 7, 84, 2, 2, 1385, 1386, 7, 67, 2, 2, 1386, 1387, 7, 78, 2, 2, 1387, 224, 3, 2, 2, 2, 1388, 1389, 7, 78, 2, 2, 1389, 1390, 7, 71, 2, 2, 1390, 1391, 7, 72, 2, 2, 1391, 1392, 7, 86, 2, 2, 1392, 226, 3, 2, 2, 2, 1393, 1394, 7, 78, 2, 2, 1394, 1395, 7, 75, 2, 2, 1395, 1396, 7, 77, 2, 2, 1396, 1397, 7, 71, 2, 2, 1397, 228, 3, 2, 2, 2, 1398, 1399, 7, 78, 2, 2, 1399, 1400, 7, 75, 2, 2, 1400, 1401, 7, 79, 2, 2, 1401, 1402, 7, 75, 2, 2, 1402, 1403, 7, 86, 2, 2, 1403, 230, 3, 2, 2, 2, 1404, 1405, 7, 78, 2, 2, 1405, 1406, 7, 75, 2, 2, 1406, 1407, 7, 80, 2, 2, 1407, 1408, 7, 71, 2, 2, 1408, 1409, 7, 85, 2, 2, 1409, 232, 3, 2, 2, 2, 1410, 1411, 7, 78, 2, 2, 1411, 1412, 7, 81, 2, 2, 1412, 1413, 7, 67, 2, 2, 1413, 1414, 7, 70, 2, 2, 1414, 234, 3, 2, 2, 2, 1415, 1416, 7, 78, 2, 2, 1416, 1417, 7, 81, 2, 2, 1417, 1418, 7, 69, 2, 2, 1418, 1419, 7, 67, 2, 2, 1419, 1420, 7, 78, 2, 2, 1420, 1421, 7, 86, 2, 2, 1421, 1422, 7, 75, 2, 2, 1422, 1423, 7, 79, 2, 2, 1423, 1424, 7, 71, 2, 2, 1424, 236, 3, 2, 2, 2, 1425, 1426, 7, 78, 2, 2, 1426, 1427, 7, 81, 2, 2, 1427, 1428, 7, 69, 2, 2, 1428, 1429, 7, 67, 2, 2, 1429, 1430, 7, 78, 2, 2, 1430, 1431, 7, 86, 2, 2, 1431, 1432, 7, 75, 2, 2, 1432, 1433, 7, 79, 2, 2, 1433, 1434, 7, 71, 2, 2, 1434, 1435, 7, 85, 2, 2, 1435, 1436, 7, 86, 2, 2, 1436, 1437, 7, 67, 2, 2, 1437, 1438, 7, 79, 2, 2, 1438, 1439, 7, 82, 2, 2, 1439, 238, 3, 2, 2, 2, 1440, 1441, 7, 79, 2, 2, 1441, 1442, 7, 71, 2, 2, 1442, 1443, 7, 86, 2, 2, 1443, 1444, 7, 67, 2, 2, 1444, 1445, 7, 70, 2, 2, 1445, 1446, 7, 67, 2, 2, 1446, 1447, 7, 86, 2, 2, 1447, 1448, 7, 67, 2, 2, 1448, 240, 3, 2, 2, 2, 1449, 1450, 7, 79, 2, 2, 1450, 1451, 7, 67, 2, 2, 1451, 1452, 7, 82, 2, 2, 1452, 242, 3, 2, 2, 2, 1453, 1454, 7, 79, 2, 2, 1454, 1455, 7, 75, 2, 2, 1455, 1456, 7, 80, 2, 2, 1456, 1457, 7, 87, 2, 2, 1457, 1458, 7, 86, 2, 2, 1458, 1459, 7, 71, 2, 2, 1459, 244, 3, 2, 2, 2, 1460, 1461, 7, 79, 2, 2, 1461, 1462, 7, 75, 2, 2, 1462, 1463, 7, 80, 2, 2, 1463, 1464, 7, 87, 2, 2, 1464, 1465, 7, 86, 2, 2, 1465, 1466, 7, 71, 2, 2, 1466, 1467, 7, 85, 2, 2, 1467, 246, 3, 2, 2, 2, 1468, 1469, 7, 79, 2, 2, 1469, 1470, 7, 81, 2, 2, 1470, 1471, 7, 80, 2, 2, 1471, 1472, 7, 86, 2, 2, 1472, 1473, 7, 74, 2, 2, 1473, 248, 3, 2, 2, 2, 1474, 1475, 7, 79, 2, 2, 1475, 1476, 7, 81, 2, 2, 1476, 1477, 7, 80, 2, 2, 1477, 1478, 7, 86, 2, 2, 1478, 1479, 7, 74, 2, 2, 1479, 1480, 7, 85, 2, 2, 1480, 250, 3, 2, 2, 2, 1481, 1482, 7, 79, 2, 2, 1482, 1483, 7, 71, 2, 2, 1483, 1484, 7, 84, 2, 2, 1484, 1485, 7, 73, 2, 2, 1485, 1486, 7, 71, 2, 2, 1486, 1487, 7, 97, 2, 2, 1487, 1488, 7, 72, 2, 2, 1488, 1489, 7, 80, 2, 2, 1489, 252, 3, 2, 2, 2, 1490, 1491, 7, 80, 2, 2, 1491, 1492, 7, 72, 2, 2, 1492, 1493, 7, 69, 2, 2, 1493, 254, 3, 2, 2, 2, 1494, 1495, 7, 80, 2, 2, 1495, 1496, 7, 72, 2, 2, 1496, 1497, 7, 70, 2, 2, 1497, 256, 3, 2, 2, 2, 1498, 1499, 7, 80, 2, 2, 1499, 1500, 7, 72, 2, 2, 1500, 1501, 7, 77, 2, 2, 1501, 1502, 7, 69, 2, 2, 1502, 258, 3, 2, 2, 2, 1503, 1504, 7, 80, 2, 2, 1504, 1505, 7, 72, 2, 2, 1505, 1506, 7, 77, 2, 2, 1506, 1507, 7, 70, 2, 2, 1507, 260, 3, 2, 2, 2, 1508, 1509, 7, 80, 2, 2, 1509, 1510, 7, 81, 2, 2, 1510, 1511, 7, 84, 2, 2, 1511, 1512, 7, 79, 2, 2, 1512, 1513, 7, 67, 2, 2, 1513, 1514, 7, 78, 2, 2, 1514, 1515, 7, 75, 2, 2, 1515, 1516, 7, 92, 2, 2, 1516, 1517, 7, 71, 2, 2, 1517, 262, 3, 2, 2, 2, 1518, 1519, 7, 80, 2, 2, 1519, 1520, 7, 81, 2, 2, 1520, 1521, 7, 86, 2, 2, 1521, 264, 3, 2, 2, 2, 1522, 1523, 7, 80, 2, 2, 1523, 1524, 7, 87, 2, 2, 1524, 1525, 7, 78, 2, 2, 1525, 1526, 7, 78, 2, 2, 1526, 266, 3, 2, 2, 2, 1527, 1528, 7, 80, 2, 2, 1528, 1529, 7, 87, 2, 2, 1529, 1530, 7, 78, 2, 2, 1530, 1531, 7, 78, 2, 2, 1531, 1532, 7, 85, 2, 2, 1532, 268, 3, 2, 2, 2, 1533, 1534, 7, 81, 2, 2, 1534, 1535, 7, 72, 2, 2, 1535, 1536, 7, 72, 2, 2, 1536, 1537, 7, 85, 2, 2, 1537, 1538, 7, 71, 2, 2, 1538, 1539, 7, 86, 2, 2, 1539, 270, 3, 2, 2, 2, 1540, 1541, 7, 81, 2, 2, 1541, 1542, 7, 80, 2, 2, 1542, 272, 3, 2, 2, 2, 1543, 1544, 7, 81, 2, 2, 1544, 1545, 7, 82, 2, 2, 1545, 1546, 7, 86, 2, 2, 1546, 1547, 7, 75, 2, 2, 1547, 1548, 7, 81, 2, 2, 1548, 1549, 7, 80, 2, 2, 1549, 274, 3, 2, 2, 2, 1550, 1551, 7, 81, 2, 2, 1551, 1552, 7, 84, 2, 2, 1552, 276, 3, 2, 2, 2, 1553, 1554, 7, 81, 2, 2, 1554, 1555, 7, 84, 2, 2, 1555, 1556, 7, 70, 2, 2, 1556, 1557, 7, 71, 2, 2, 1557, 1558, 7, 84, 2, 2, 1558, 278, 3, 2, 2, 2, 1559, 1560, 7, 81, 2, 2, 1560, 1561, 7, 84, 2, 2, 1561, 1562, 7, 70, 2, 2, 1562, 1563, 7, 75, 2, 2, 1563, 1564, 7, 80, 2, 2, 1564, 1565, 7, 67, 2, 2, 1565, 1566, 7, 78, 2, 2, 1566, 1567, 7, 75, 2, 2, 1567, 1568, 7, 86, 2, 2, 1568, 1569, 7, 91, 2, 2, 1569, 280, 3, 2, 2, 2, 1570, 1571, 7, 81, 2, 2, 1571, 1572, 7, 87, 2, 2, 1572, 1573, 7, 86, 2, 2, 1573, 1574, 7, 71, 2, 2, 1574, 1575, 7, 84, 2, 2, 1575, 282, 3, 2, 2, 2, 1576, 1577, 7, 81, 2, 2, 1577, 1578, 7, 89, 2, 2, 1578, 1579, 7, 80, 2, 2, 1579, 1580, 7, 71, 2, 2, 1580, 1581, 7, 84, 2, 2, 1581, 284, 3, 2, 2, 2, 1582, 1583, 7, 81, 2, 2, 1583, 1584, 7, 88, 2, 2, 1584, 1585, 7, 71, 2, 2, 1585, 1586, 7, 84, 2, 2, 1586, 286, 3, 2, 2, 2, 1587, 1588, 7, 81, 2, 2, 1588, 1589, 7, 88, 2, 2, 1589, 1590, 7, 71, 2, 2, 1590, 1591, 7, 84, 2, 2, 1591, 1592, 7, 89, 2, 2, 1592, 1593, 7, 84, 2, 2, 1593, 1594, 7, 75, 2, 2, 1594, 1595, 7, 86, 2, 2, 1595, 1596, 7, 71, 2, 2, 1596, 288, 3, 2, 2, 2, 1597, 1598, 7, 82, 2, 2, 1598, 1599, 7, 67, 2, 2, 1599, 1600, 7, 84, 2, 2, 1600, 1601, 7, 86, 2, 2, 1601, 1602, 7, 75, 2, 2, 1602, 1603, 7, 86, 2, 2, 1603, 1604, 7, 75, 2, 2, 1604, 1605, 7, 81, 2, 2, 1605, 1606, 7, 80, 2, 2, 1606, 290, 3, 2, 2, 2, 1607, 1608, 7, 82, 2, 2, 1608, 1609, 7, 67, 2, 2, 1609, 1610, 7, 84, 2, 2, 1610, 1611, 7, 86, 2, 2, 1611, 1612, 7, 75, 2, 2, 1612, 1613, 7, 86, 2, 2, 1613, 1614, 7, 75, 2, 2, 1614, 1615, 7, 81, 2, 2, 1615, 1616, 7, 80, 2, 2, 1616, 1617, 7, 85, 2, 2, 1617, 292, 3, 2, 2, 2, 1618, 1619, 7, 82, 2, 2, 1619, 1620, 7, 67, 2, 2, 1620, 1621, 7, 84, 2, 2, 1621, 1622, 7, 83, 2, 2, 1622, 1623, 7, 87, 2, 2, 1623, 1624, 7, 71, 2, 2, 1624, 1625, 7, 86, 2, 2, 1625, 294, 3, 2, 2, 2, 1626, 1627, 7, 82, 2, 2, 1627, 1628, 7, 81, 2, 2, 1628, 1629, 7, 85, 2, 2, 1629, 1630, 7, 75, 2, 2, 1630, 1631, 7, 86, 2, 2, 1631, 1632, 7, 75, 2, 2, 1632, 1633, 7, 81, 2, 2, 1633, 1634, 7, 80, 2, 2, 1634, 296, 3, 2, 2, 2, 1635, 1636, 7, 82, 2, 2, 1636, 1637, 7, 84, 2, 2, 1637, 1638, 7, 71, 2, 2, 1638, 1639, 7, 69, 2, 2, 1639, 1640, 7, 71, 2, 2, 1640, 1641, 7, 70, 2, 2, 1641, 1642, 7, 75, 2, 2, 1642, 1643, 7, 80, 2, 2, 1643, 1644, 7, 73, 2, 2, 1644, 298, 3, 2, 2, 2, 1645, 1646, 7, 82, 2, 2, 1646, 1647, 7, 84, 2, 2, 1647, 1648, 7, 75, 2, 2, 1648, 1649, 7, 79, 2, 2, 1649, 1650, 7, 67, 2, 2, 1650, 1651, 7, 84, 2, 2, 1651, 1652, 7, 91, 2, 2, 1652, 300, 3, 2, 2, 2, 1653, 1654, 7, 84, 2, 2, 1654, 1655, 7, 71, 2, 2, 1655, 1656, 7, 82, 2, 2, 1656, 1657, 7, 78, 2, 2, 1657, 1658, 7, 75, 2, 2, 1658, 1659, 7, 69, 2, 2, 1659, 1660, 7, 67, 2, 2, 1660, 1661, 7, 86, 2, 2, 1661, 1662, 7, 75, 2, 2, 1662, 1663, 7, 81, 2, 2, 1663, 1664, 7, 80, 2, 2, 1664, 302, 3, 2, 2, 2, 1665, 1666, 7, 82, 2, 2, 1666, 1667, 7, 84, 2, 2, 1667, 1668, 7, 75, 2, 2, 1668, 1669, 7, 88, 2, 2, 1669, 1670, 7, 75, 2, 2, 1670, 1671, 7, 78, 2, 2, 1671, 1672, 7, 71, 2, 2, 1672, 1673, 7, 73, 2, 2, 1673, 1674, 7, 71, 2, 2, 1674, 1675, 7, 85, 2, 2, 1675, 304, 3, 2, 2, 2, 1676, 1677, 7, 82, 2, 2, 1677, 1678, 7, 84, 2, 2, 1678, 1679, 7, 81, 2, 2, 1679, 1680, 7, 82, 2, 2, 1680, 1681, 7, 71, 2, 2, 1681, 1682, 7, 84, 2, 2, 1682, 1683, 7, 86, 2, 2, 1683, 1684, 7, 75, 2, 2, 1684, 1685, 7, 71, 2, 2, 1685, 1686, 7, 85, 2, 2, 1686, 306, 3, 2, 2, 2, 1687, 1688, 7, 84, 2, 2, 1688, 1689, 7, 67, 2, 2, 1689, 1690, 7, 80, 2, 2, 1690, 1691, 7, 73, 2, 2, 1691, 1692, 7, 71, 2, 2, 1692, 308, 3, 2, 2, 2, 1693, 1694, 7, 84, 2, 2, 1694, 1695, 7, 71, 2, 2, 1695, 1696, 7, 69, 2, 2, 1696, 1697, 7, 81, 2, 2, 1697, 1698, 7, 88, 2, 2, 1698, 1699, 7, 71, 2, 2, 1699, 1700, 7, 84, 2, 2, 1700, 310, 3, 2, 2, 2, 1701, 1702, 7, 84, 2, 2, 1702, 1703, 7, 71, 2, 2, 1703, 1704, 7, 80, 2, 2, 1704, 1705, 7, 67, 2, 2, 1705, 1706, 7, 79, 2, 2, 1706, 1707, 7, 71, 2, 2, 1707, 312, 3, 2, 2, 2, 1708, 1709, 7, 84, 2, 2, 1709, 1710, 7, 71, 2, 2, 1710, 1711, 7, 82, 2, 2, 1711, 1712, 7, 71, 2, 2, 1712, 1713, 7, 67, 2, 2, 1713, 1714, 7, 86, 2, 2, 1714, 1715, 7, 67, 2, 2, 1715, 1716, 7, 68, 2, 2, 1716, 1717, 7, 78, 2, 2, 1717, 1718, 7, 71, 2, 2, 1718, 314, 3, 2, 2, 2, 1719, 1720, 7, 84, 2, 2, 1720, 1721, 7, 71, 2, 2, 1721, 1722, 7, 82, 2, 2, 1722, 1723, 7, 78, 2, 2, 1723, 1724, 7, 67, 2, 2, 1724, 1725, 7, 69, 2, 2, 1725, 1726, 7, 71, 2, 2, 1726, 316, 3, 2, 2, 2, 1727, 1728, 7, 84, 2, 2, 1728, 1729, 7, 71, 2, 2, 1729, 1730, 7, 85, 2, 2, 1730, 1731, 7, 86, 2, 2, 1731, 1732, 7, 84, 2, 2, 1732, 1733, 7, 75, 2, 2, 1733, 1734, 7, 69, 2, 2, 1734, 1735, 7, 86, 2, 2, 1735, 318, 3, 2, 2, 2, 1736, 1737, 7, 84, 2, 2, 1737, 1738, 7, 71, 2, 2, 1738, 1739, 7, 86, 2, 2, 1739, 1740, 7, 87, 2, 2, 1740, 1741, 7, 84, 2, 2, 1741, 1742, 7, 80, 2, 2, 1742, 1743, 7, 85, 2, 2, 1743, 320, 3, 2, 2, 2, 1744, 1745, 7, 84, 2, 2, 1745, 1746, 7, 71, 2, 2, 1746, 1747, 7, 88, 2, 2, 1747, 1748, 7, 81, 2, 2, 1748, 1749, 7, 77, 2, 2, 1749, 1750, 7, 71, 2, 2, 1750, 322, 3, 2, 2, 2, 1751, 1752, 7, 84, 2, 2, 1752, 1753, 7, 71, 2, 2, 1753, 1754, 7, 72, 2, 2, 1754, 1755, 7, 84, 2, 2, 1755, 1756, 7, 71, 2, 2, 1756, 1757, 7, 85, 2, 2, 1757, 1758, 7, 74, 2, 2, 1758, 324, 3, 2, 2, 2, 1759, 1760, 7, 84, 2, 2, 1760, 1761, 7, 71, 2, 2, 1761, 1762, 7, 73, 2, 2, 1762, 1763, 7, 71, 2, 2, 1763, 1764, 7, 90, 2, 2, 1764, 1765, 7, 82, 2, 2, 1765, 326, 3, 2, 2, 2, 1766, 1767, 7, 84, 2, 2, 1767, 1768, 7, 78, 2, 2, 1768, 1769, 7, 75, 2, 2, 1769, 1770, 7, 77, 2, 2, 1770, 1771, 7, 71, 2, 2, 1771, 328, 3, 2, 2, 2, 1772, 1773, 7, 84, 2, 2, 1773, 1774, 7, 75, 2, 2, 1774, 1775, 7, 73, 2, 2, 1775, 1776, 7, 74, 2, 2, 1776, 1777, 7, 86, 2, 2, 1777, 330, 3, 2, 2, 2, 1778, 1779, 7, 84, 2, 2, 1779, 1780, 7, 81, 2, 2, 1780, 1781, 7, 78, 2, 2, 1781, 1782, 7, 71, 2, 2, 1782, 332, 3, 2, 2, 2, 1783, 1784, 7, 84, 2, 2, 1784, 1785, 7, 81, 2, 2, 1785, 1786, 7, 78, 2, 2, 1786, 1787, 7, 71, 2, 2, 1787, 1788, 7, 85, 2, 2, 1788, 334, 3, 2, 2, 2, 1789, 1790, 7, 84, 2, 2, 1790, 1791, 7, 81, 2, 2, 1791, 1792, 7, 89, 2, 2, 1792, 336, 3, 2, 2, 2, 1793, 1794, 7, 84, 2, 2, 1794, 1795, 7, 81, 2, 2, 1795, 1796, 7, 89, 2, 2, 1796, 1797, 7, 85, 2, 2, 1797, 338, 3, 2, 2, 2, 1798, 1799, 7, 85, 2, 2, 1799, 1800, 7, 69, 2, 2, 1800, 1801, 7, 74, 2, 2, 1801, 1802, 7, 71, 2, 2, 1802, 1803, 7, 79, 2, 2, 1803, 1804, 7, 67, 2, 2, 1804, 340, 3, 2, 2, 2, 1805, 1806, 7, 85, 2, 2, 1806, 1807, 7, 69, 2, 2, 1807, 1808, 7, 74, 2, 2, 1808, 1809, 7, 71, 2, 2, 1809, 1810, 7, 79, 2, 2, 1810, 1811, 7, 67, 2, 2, 1811, 1812, 7, 85, 2, 2, 1812, 342, 3, 2, 2, 2, 1813, 1814, 7, 85, 2, 2, 1814, 1815, 7, 71, 2, 2, 1815, 1816, 7, 69, 2, 2, 1816, 1817, 7, 81, 2, 2, 1817, 1818, 7, 80, 2, 2, 1818, 1819, 7, 70, 2, 2, 1819, 344, 3, 2, 2, 2, 1820, 1821, 7, 85, 2, 2, 1821, 1822, 7, 71, 2, 2, 1822, 1823, 7, 69, 2, 2, 1823, 1824, 7, 81, 2, 2, 1824, 1825, 7, 80, 2, 2, 1825, 1826, 7, 70, 2, 2, 1826, 1827, 7, 85, 2, 2, 1827, 346, 3, 2, 2, 2, 1828, 1829, 7, 85, 2, 2, 1829, 1830, 7, 71, 2, 2, 1830, 1831, 7, 78, 2, 2, 1831, 1832, 7, 71, 2, 2, 1832, 1833, 7, 69, 2, 2, 1833, 1834, 7, 86, 2, 2, 1834, 348, 3, 2, 2, 2, 1835, 1836, 7, 85, 2, 2, 1836, 1837, 7, 71, 2, 2, 1837, 1838, 7, 84, 2, 2, 1838, 1839, 7, 70, 2, 2, 1839, 1840, 7, 71, 2, 2, 1840, 1841, 7, 82, 2, 2, 1841, 1842, 7, 84, 2, 2, 1842, 1843, 7, 81, 2, 2, 1843, 1844, 7, 82, 2, 2, 1844, 1845, 7, 71, 2, 2, 1845, 1846, 7, 84, 2, 2, 1846, 1847, 7, 86, 2, 2, 1847, 1848, 7, 75, 2, 2, 1848, 1849, 7, 71, 2, 2, 1849, 1850, 7, 85, 2, 2, 1850, 350, 3, 2, 2, 2, 1851, 1852, 7, 85, 2, 2, 1852, 1853, 7, 71, 2, 2, 1853, 1854, 7, 86, 2, 2, 1854, 352, 3, 2, 2, 2, 1855, 1856, 7, 85, 2, 2, 1856, 1857, 7, 71, 2, 2, 1857, 1858, 7, 79, 2, 2, 1858, 1859, 7, 75, 2, 2, 1859, 354, 3, 2, 2, 2, 1860, 1861, 7, 85, 2, 2, 1861, 1862, 7, 71, 2, 2, 1862, 1863, 7, 84, 2, 2, 1863, 1864, 7, 88, 2, 2, 1864, 1865, 7, 71, 2, 2, 1865, 1866, 7, 84, 2, 2, 1866, 356, 3, 2, 2, 2, 1867, 1868, 7, 85, 2, 2, 1868, 1869, 7, 74, 2, 2, 1869, 1870, 7, 81, 2, 2, 1870, 1871, 7, 89, 2, 2, 1871, 358, 3, 2, 2, 2, 1872, 1873, 7, 85, 2, 2, 1873, 1874, 7, 74, 2, 2, 1874, 1875, 7, 87, 2, 2, 1875, 1876, 7, 86, 2, 2, 1876, 1877, 7, 70, 2, 2, 1877, 1878, 7, 81, 2, 2, 1878, 1879, 7, 89, 2, 2, 1879, 1880, 7, 80, 2, 2, 1880, 360, 3, 2, 2, 2, 1881, 1882, 7, 85, 2, 2, 1882, 1883, 7, 81, 2, 2, 1883, 1884, 7, 79, 2, 2, 1884, 1885, 7, 71, 2, 2, 1885, 362, 3, 2, 2, 2, 1886, 1887, 7, 85, 2, 2, 1887, 1888, 7, 86, 2, 2, 1888, 1889, 7, 67, 2, 2, 1889, 1890, 7, 86, 2, 2, 1890, 1891, 7, 85, 2, 2, 1891, 364, 3, 2, 2, 2, 1892, 1893, 7, 85, 2, 2, 1893, 1894, 7, 86, 2, 2, 1894, 1895, 7, 84, 2, 2, 1895, 1896, 7, 87, 2, 2, 1896, 1897, 7, 69, 2, 2, 1897, 1898, 7, 86, 2, 2, 1898, 366, 3, 2, 2, 2, 1899, 1900, 7, 85, 2, 2, 1900, 1901, 7, 86, 2, 2, 1901, 1902, 7, 84, 2, 2, 1902, 1903, 7, 67, 2, 2, 1903, 1904, 7, 75, 2, 2, 1904, 1905, 7, 73, 2, 2, 1905, 1906, 7, 74, 2, 2, 1906, 1907, 7, 86, 2, 2, 1907, 1908, 7, 97, 2, 2, 1908, 1909, 7, 76, 2, 2, 1909, 1910, 7, 81, 2, 2, 1910, 1911, 7, 75, 2, 2, 1911, 1912, 7, 80, 2, 2, 1912, 368, 3, 2, 2, 2, 1913, 1914, 7, 85, 2, 2, 1914, 1915, 7, 87, 2, 2, 1915, 1916, 7, 68, 2, 2, 1916, 1917, 7, 85, 2, 2, 1917, 1918, 7, 86, 2, 2, 1918, 1919, 7, 84, 2, 2, 1919, 1920, 7, 75, 2, 2, 1920, 1921, 7, 80, 2, 2, 1921, 1922, 7, 73, 2, 2, 1922, 370, 3, 2, 2, 2, 1923, 1924, 7, 85, 2, 2, 1924, 1925, 7, 91, 2, 2, 1925, 1926, 7, 85, 2, 2, 1926, 1927, 7, 86, 2, 2, 1927, 1928, 7, 71, 2, 2, 1928, 1929, 7, 79, 2, 2, 1929, 372, 3, 2, 2, 2, 1930, 1931, 7, 85, 2, 2, 1931, 1932, 7, 91, 2, 2, 1932, 1933, 7, 79, 2, 2, 1933, 1934, 7, 68, 2, 2, 1934, 1935, 7, 81, 2, 2, 1935, 1936, 7, 78, 2, 2, 1936, 374, 3, 2, 2, 2, 1937, 1938, 7, 85, 2, 2, 1938, 1939, 7, 71, 2, 2, 1939, 1940, 7, 84, 2, 2, 1940, 1941, 7, 75, 2, 2, 1941, 1942, 7, 67, 2, 2, 1942, 1943, 7, 78, 2, 2, 1943, 1944, 7, 75, 2, 2, 1944, 1945, 7, 92, 2, 2, 1945, 1946, 7, 71, 2, 2, 1946, 1947, 7, 97, 2, 2, 1947, 1948, 7, 72, 2, 2, 1948, 1949, 7, 80, 2, 2, 1949, 376, 3, 2, 2, 2, 1950, 1951, 7, 86, 2, 2, 1951, 1952, 7, 67, 2, 2, 1952, 1953, 7, 68, 2, 2, 1953, 1954, 7, 78, 2, 2, 1954, 1955, 7, 71, 2, 2, 1955, 378, 3, 2, 2, 2, 1956, 1957, 7, 86, 2, 2, 1957, 1958, 7, 67, 2, 2, 1958, 1959, 7, 68, 2, 2, 1959, 1960, 7, 78, 2, 2, 1960, 1961, 7, 71, 2, 2, 1961, 1962, 7, 85, 2, 2, 1962, 380, 3, 2, 2, 2, 1963, 1964, 7, 86, 2, 2, 1964, 1965, 7, 67, 2, 2, 1965, 1966, 7, 68, 2, 2, 1966, 1967, 7, 78, 2, 2, 1967, 1968, 7, 71, 2, 2, 1968, 1969, 7, 85, 2, 2, 1969, 1970, 7, 67, 2, 2, 1970, 1971, 7, 79, 2, 2, 1971, 1972, 7, 82, 2, 2, 1972, 1973, 7, 78, 2, 2, 1973, 1974, 7, 71, 2, 2, 1974, 382, 3, 2, 2, 2, 1975, 1976, 7, 86, 2, 2, 1976, 1977, 7, 71, 2, 2, 1977, 1978, 7, 84, 2, 2, 1978, 1979, 7, 79, 2, 2, 1979, 1980, 7, 75, 2, 2, 1980, 1981, 7, 80, 2, 2, 1981, 1982, 7, 67, 2, 2, 1982, 1983, 7, 86, 2, 2, 1983, 1984, 7, 71, 2, 2, 1984, 1985, 7, 70, 2, 2, 1985, 1986, 7, 34, 2, 2, 1986, 384, 3, 2, 2, 2, 1987, 1988, 7, 86, 2, 2, 1988, 1989, 7, 74, 2, 2, 1989, 1990, 7, 71, 2, 2, 1990, 1991, 7, 80, 2, 2, 1991, 386, 3, 2, 2, 2, 1992, 1993, 7, 86, 2, 2, 1993, 1994, 7, 81, 2, 2, 1994, 388, 3, 2, 2, 2, 1995, 1996, 7, 86, 2, 2, 1996, 1997, 7, 84, 2, 2, 1997, 1998, 7, 87, 2, 2, 1998, 1999, 7, 71, 2, 2, 1999, 390, 3, 2, 2, 2, 2000, 2001, 7, 86, 2, 2, 2001, 2002, 7, 84, 2, 2, 2002, 2003, 7, 91, 2, 2, 2003, 2004, 7, 97, 2, 2, 2004, 2005, 7, 69, 2, 2, 2005, 2006, 7, 67, 2, 2, 2006, 2007, 7, 85, 2, 2, 2007, 2008, 7, 86, 2, 2, 2008, 392, 3, 2, 2, 2, 2009, 2010, 7, 86, 2, 2, 2010, 2011, 7, 84, 2, 2, 2011, 2012, 7, 87, 2, 2, 2012, 2013, 7, 80, 2, 2, 2013, 2014, 7, 69, 2, 2, 2014, 2015, 7, 67, 2, 2, 2015, 2016, 7, 86, 2, 2, 2016, 2017, 7, 71, 2, 2, 2017, 394, 3, 2, 2, 2, 2018, 2019, 7, 87, 2, 2, 2019, 2020, 7, 80, 2, 2, 2020, 2021, 7, 69, 2, 2, 2021, 2022, 7, 67, 2, 2, 2022, 2023, 7, 69, 2, 2, 2023, 2024, 7, 74, 2, 2, 2024, 2025, 7, 71, 2, 2, 2025, 2026, 7, 70, 2, 2, 2026, 396, 3, 2, 2, 2, 2027, 2028, 7, 87, 2, 2, 2028, 2029, 7, 71, 2, 2, 2029, 2030, 7, 85, 2, 2, 2030, 2031, 7, 69, 2, 2, 2031, 2032, 7, 67, 2, 2, 2032, 2033, 7, 82, 2, 2, 2033, 2034, 7, 71, 2, 2, 2034, 398, 3, 2, 2, 2, 2035, 2036, 7, 87, 2, 2, 2036, 2037, 7, 80, 2, 2, 2037, 2038, 7, 68, 2, 2, 2038, 2039, 7, 81, 2, 2, 2039, 2040, 7, 87, 2, 2, 2040, 2041, 7, 80, 2, 2, 2041, 2042, 7, 70, 2, 2, 2042, 2043, 7, 71, 2, 2, 2043, 2044, 7, 70, 2, 2, 2044, 400, 3, 2, 2, 2, 2045, 2046, 7, 87, 2, 2, 2046, 2047, 7, 80, 2, 2, 2047, 2048, 7, 75, 2, 2, 2048, 2049, 7, 81, 2, 2, 2049, 2050, 7, 80, 2, 2, 2050, 402, 3, 2, 2, 2, 2051, 2052, 7, 87, 2, 2, 2052, 2053, 7, 80, 2, 2, 2053, 2054, 7, 80, 2, 2, 2054, 2055, 7, 71, 2, 2, 2055, 2056, 7, 85, 2, 2, 2056, 2057, 7, 86, 2, 2, 2057, 404, 3, 2, 2, 2, 2058, 2059, 7, 87, 2, 2, 2059, 2060, 7, 80, 2, 2, 2060, 2061, 7, 85, 2, 2, 2061, 2062, 7, 71, 2, 2, 2062, 2063, 7, 86, 2, 2, 2063, 406, 3, 2, 2, 2, 2064, 2065, 7, 87, 2, 2, 2065, 2066, 7, 85, 2, 2, 2066, 2067, 7, 71, 2, 2, 2067, 408, 3, 2, 2, 2, 2068, 2069, 7, 87, 2, 2, 2069, 2070, 7, 85, 2, 2, 2070, 2071, 7, 71, 2, 2, 2071, 2072, 7, 84, 2, 2, 2072, 410, 3, 2, 2, 2, 2073, 2074, 7, 87, 2, 2, 2074, 2075, 7, 85, 2, 2, 2075, 2076, 7, 75, 2, 2, 2076, 2077, 7, 80, 2, 2, 2077, 2078, 7, 73, 2, 2, 2078, 412, 3, 2, 2, 2, 2079, 2080, 7, 87, 2, 2, 2080, 2081, 7, 82, 2, 2, 2081, 2082, 7, 70, 2, 2, 2082, 2083, 7, 67, 2, 2, 2083, 2084, 7, 86, 2, 2, 2084, 2085, 7, 71, 2, 2, 2085, 2086, 7, 97, 2, 2, 2086, 2087, 7, 72, 2, 2, 2087, 2088, 7, 80, 2, 2, 2088, 414, 3, 2, 2, 2, 2089, 2090, 7, 87, 2, 2, 2090, 2091, 7, 82, 2, 2, 2091, 2092, 7, 85, 2, 2, 2092, 2093, 7, 71, 2, 2, 2093, 2094, 7, 84, 2, 2, 2094, 2095, 7, 86, 2, 2, 2095, 416, 3, 2, 2, 2, 2096, 2097, 7, 87, 2, 2, 2097, 2098, 7, 84, 2, 2, 2098, 2099, 7, 75, 2, 2, 2099, 418, 3, 2, 2, 2, 2100, 2101, 7, 88, 2, 2, 2101, 2102, 7, 67, 2, 2, 2102, 2103, 7, 78, 2, 2, 2103, 2104, 7, 87, 2, 2, 2104, 2105, 7, 71, 2, 2, 2105, 420, 3, 2, 2, 2, 2106, 2107, 7, 88, 2, 2, 2107, 2108, 7, 67, 2, 2, 2108, 2109, 7, 78, 2, 2, 2109, 2110, 7, 87, 2, 2, 2110, 2111, 7, 71, 2, 2, 2111, 2112, 7, 85, 2, 2, 2112, 422, 3, 2, 2, 2, 2113, 2114, 7, 88, 2, 2, 2114, 2115, 7, 75, 2, 2, 2115, 2116, 7, 71, 2, 2, 2116, 2117, 7, 89, 2, 2, 2117, 424, 3, 2, 2, 2, 2118, 2119, 7, 88, 2, 2, 2119, 2120, 7, 75, 2, 2, 2120, 2121, 7, 71, 2, 2, 2121, 2122, 7, 89, 2, 2, 2122, 2123, 7, 85, 2, 2, 2123, 426, 3, 2, 2, 2, 2124, 2125, 7, 89, 2, 2, 2125, 2126, 7, 74, 2, 2, 2126, 2127, 7, 71, 2, 2, 2127, 2128, 7, 80, 2, 2, 2128, 428, 3, 2, 2, 2, 2129, 2130, 7, 89, 2, 2, 2130, 2131, 7, 74, 2, 2, 2131, 2132, 7, 71, 2, 2, 2132, 2133, 7, 84, 2, 2, 2133, 2134, 7, 71, 2, 2, 2134, 430, 3, 2, 2, 2, 2135, 2136, 7, 89, 2, 2, 2136, 2137, 7, 75, 2, 2, 2137, 2138, 7, 86, 2, 2, 2138, 2139, 7, 74, 2, 2, 2139, 432, 3, 2, 2, 2, 2140, 2141, 7, 91, 2, 2, 2141, 2142, 7, 71, 2, 2, 2142, 2143, 7, 67, 2, 2, 2143, 2144, 7, 84, 2, 2, 2144, 434, 3, 2, 2, 2, 2145, 2146, 7, 91, 2, 2, 2146, 2147, 7, 71, 2, 2, 2147, 2148, 7, 67, 2, 2, 2148, 2149, 7, 84, 2, 2, 2149, 2150, 7, 85, 2, 2, 2150, 436, 3, 2, 2, 2, 2151, 2152, 7, 86, 2, 2, 2152, 2153, 7, 71, 2, 2, 2153, 2154, 7, 90, 2, 2, 2154, 2155, 7, 86, 2, 2, 2155, 2156, 7, 72, 2, 2, 2156, 2157, 7, 75, 2, 2, 2157, 2158, 7, 78, 2, 2, 2158, 2159, 7, 71, 2, 2, 2159, 438, 3, 2, 2, 2, 2160, 2161, 7, 81, 2, 2, 2161, 2162, 7, 84, 2, 2, 2162, 2163, 7, 69, 2, 2, 2163, 440, 3, 2, 2, 2, 2164, 2165, 7, 67, 2, 2, 2165, 2166, 7, 88, 2, 2, 2166, 2167, 7, 84, 2, 2, 2167, 2168, 7, 81, 2, 2, 2168, 442, 3, 2, 2, 2, 2169, 2170, 7, 85, 2, 2, 2170, 2171, 7, 71, 2, 2, 2171, 2172, 7, 83, 2, 2, 2172, 2173, 7, 87, 2, 2, 2173, 2174, 7, 71, 2, 2, 2174, 2175, 7, 80, 2, 2, 2175, 2176, 7, 69, 2, 2, 2176, 2177, 7, 71, 2, 2, 2177, 2178, 7, 72, 2, 2, 2178, 2179, 7, 75, 2, 2, 2179, 2180, 7, 78, 2, 2, 2180, 2181, 7, 71, 2, 2, 2181, 444, 3, 2, 2, 2, 2182, 2183, 7, 84, 2, 2, 2183, 2184, 7, 69, 2, 2, 2184, 2185, 7, 72, 2, 2, 2185, 2186, 7, 75, 2, 2, 2186, 2187, 7, 78, 2, 2, 2187, 2188, 7, 71, 2, 2, 2188, 446, 3, 2, 2, 2, 2189, 2190, 7, 84, 2, 2, 2190, 2191, 7, 71, 2, 2, 2191, 2192, 7, 72, 2, 2, 2192, 2193, 7, 71, 2, 2, 2193, 2194, 7, 84, 2, 2, 2194, 2195, 7, 71, 2, 2, 2195, 2196, 7, 80, 2, 2, 2196, 2197, 7, 69, 2, 2, 2197, 2198, 7, 71, 2, 2, 2198, 2199, 7, 85, 2, 2, 2199, 448, 3, 2, 2, 2, 2200, 2201, 7, 80, 2, 2, 2201, 2202, 7, 81, 2, 2, 2202, 2203, 7, 88, 2, 2, 2203, 2204, 7, 67, 2, 2, 2204, 2205, 7, 78, 2, 2, 2205, 2206, 7, 75, 2, 2, 2206, 2207, 7, 70, 2, 2, 2207, 2208, 7, 67, 2, 2, 2208, 2209, 7, 86, 2, 2, 2209, 2210, 7, 71, 2, 2, 2210, 450, 3, 2, 2, 2, 2211, 2212, 7, 84, 2, 2, 2212, 2213, 7, 71, 2, 2, 2213, 2214, 7, 78, 2, 2, 2214, 2215, 7, 91, 2, 2, 2215, 452, 3, 2, 2, 2, 2216, 2217, 7, 41, 2, 2, 2217, 2218, 7, 80, 2, 2, 2218, 2219, 7, 87, 2, 2, 2219, 2220, 7, 79, 2, 2, 2220, 2221, 7, 70, 2, 2, 2221, 2222, 7, 88, 2, 2, 2222, 2223, 7, 85, 2, 2, 2223, 2224, 7, 41, 2, 2, 2224, 454, 3, 2, 2, 2, 2225, 2226, 7, 41, 2, 2, 2226, 2227, 7, 80, 2, 2, 2227, 2228, 7, 87, 2, 2, 2228, 2229, 7, 79, 2, 2, 2229, 2230, 7, 80, 2, 2, 2230, 2231, 7, 87, 2, 2, 2231, 2232, 7, 78, 2, 2, 2232, 2233, 7, 78, 2, 2, 2233, 2234, 7, 85, 2, 2, 2234, 2235, 7, 41, 2, 2, 2235, 456, 3, 2, 2, 2, 2236, 2237, 7, 41, 2, 2, 2237, 2238, 7, 67, 2, 2, 2238, 2239, 7, 88, 2, 2, 2239, 2240, 7, 73, 2, 2, 2240, 2241, 7, 85, 2, 2, 2241, 2242, 7, 75, 2, 2, 2242, 2243, 7, 92, 2, 2, 2243, 2244, 7, 71, 2, 2, 2244, 2245, 7, 41, 2, 2, 2245, 458, 3, 2, 2, 2, 2246, 2247, 7, 41, 2, 2, 2247, 2248, 7, 79, 2, 2, 2248, 2249, 7, 67, 2, 2, 2249, 2250, 7, 90, 2, 2, 2250, 2251, 7, 85, 2, 2, 2251, 2252, 7, 75, 2, 2, 2252, 2253, 7, 92, 2, 2, 2253, 2254, 7, 71, 2, 2, 2254, 2255, 7, 41, 2, 2, 2255, 460, 3, 2, 2, 2, 2256, 2257, 7, 63, 2, 2, 2257, 462, 3, 2, 2, 2, 2258, 2259, 7, 62, 2, 2, 2259, 2263, 7, 64, 2, 2, 2260, 2261, 7, 35, 2, 2, 2261, 2263, 7, 63, 2, 2, 2262, 2258, 3, 2, 2, 2, 2262, 2260, 3, 2, 2, 2, 2263, 464, 3, 2, 2, 2, 2264, 2265, 7, 62, 2, 2, 2265, 466, 3, 2, 2, 2, 2266, 2267, 7, 62, 2, 2, 2267, 2268, 7, 63, 2, 2, 2268, 468, 3, 2, 2, 2, 2269, 2270, 7, 64, 2, 2, 2270, 470, 3, 2, 2, 2, 2271, 2272, 7, 64, 2, 2, 2272, 2273, 7, 63, 2, 2, 2273, 472, 3, 2, 2, 2, 2274, 2275, 7, 45, 2, 2, 2275, 474, 3, 2, 2, 2, 2276, 2277, 7, 47, 2, 2, 2277, 476, 3, 2, 2, 2, 2278, 2279, 7, 44, 2, 2, 2279, 478, 3, 2, 2, 2, 2280, 2281, 7, 49, 2, 2, 2281, 480, 3, 2, 2, 2, 2282, 2283, 7, 39, 2, 2, 2283, 482, 3, 2, 2, 2, 2284, 2285, 7, 126, 2, 2, 2285, 2286, 7, 126, 2, 2, 2286, 484, 3, 2, 2, 2, 2287, 2288, 7, 48, 2, 2, 2288, 486, 3, 2, 2, 2, 2289, 2290, 7, 61, 2, 2, 2290, 488, 3, 2, 2, 2, 2291, 2292, 7, 46, 2, 2, 2292, 490, 3, 2, 2, 2, 2293, 2294, 7, 60, 2, 2, 2294, 492, 3, 2, 2, 2, 2295, 2296, 7, 42, 2, 2, 2296, 494, 3, 2, 2, 2, 2297, 2298, 7, 43, 2, 2, 2298, 496, 3, 2, 2, 2, 2299, 2300, 7, 93, 2, 2, 2300, 498, 3, 2, 2, 2, 2301, 2302, 7, 95, 2, 2, 2302, 500, 3, 2, 2, 2, 2303, 2304, 7, 125, 2, 2, 2304, 502, 3, 2, 2, 2, 2305, 2306, 7, 127, 2, 2, 2306, 504, 3, 2, 2, 2, 2307, 2308, 7, 126, 2, 2, 2308, 506, 3, 2, 2, 2, 2309, 2310, 7, 65, 2, 2, 2310, 508, 3, 2, 2, 2, 2311, 2312, 7, 47, 2, 2, 2312, 2313, 7, 64, 2, 2, 2313, 510, 3, 2, 2, 2, 2314, 2320, 7, 41, 2, 2, 2315, 2319, 10, 2, 2, 2, 2316, 2317, 7, 41, 2, 2, 2317, 2319, 7, 41, 2, 2, 2318, 2315, 3, 2, 2, 2, 2318, 2316, 3, 2, 2, 2, 2319, 2322, 3, 2, 2, 2, 2320, 2318, 3, 2, 2, 2, 2320, 2321, 3, 2, 2, 2, 2321, 2323, 3, 2, 2, 2, 2322, 2320, 3, 2, 2, 2, 2323, 2335, 7, 41, 2, 2, 2324, 2330, 7, 36, 2, 2, 2325, 2329, 10, 3, 2, 2, 2326, 2327, 7, 36, 2, 2, 2327, 2329, 7, 36, 2, 2, 2328, 2325, 3, 2, 2, 2, 2328, 2326, 3, 2, 2, 2, 2329, 2332, 3, 2, 2, 2, 2330, 2328, 3, 2, 2, 2, 2330, 2331, 3, 2, 2, 2, 2331, 2333, 3, 2, 2, 2, 2332, 2330, 3, 2, 2, 2, 2333, 2335, 7, 36, 2, 2, 2334, 2314, 3, 2, 2, 2, 2334, 2324, 3, 2, 2, 2, 2335, 512, 3, 2, 2, 2, 2336, 2337, 7, 87, 2, 2, 2337, 2338, 7, 40, 2, 2, 2338, 2339, 7, 41, 2, 2, 2339, 2345, 3, 2, 2, 2, 2340, 2344, 10, 2, 2, 2, 2341, 2342, 7, 41, 2, 2, 2342, 2344, 7, 41, 2, 2, 2343, 2340, 3, 2, 2, 2, 2343, 2341, 3, 2, 2, 2, 2344, 2347, 3, 2, 2, 2, 2345, 2343, 3, 2, 2, 2, 2345, 2346, 3, 2, 2, 2, 2346, 2348, 3, 2, 2, 2, 2347, 2345, 3, 2, 2, 2, 2348, 2349, 7, 41, 2, 2, 2349, 514, 3, 2, 2, 2, 2350, 2351, 7, 90, 2, 2, 2351, 2352, 7, 41, 2, 2, 2352, 2356, 3, 2, 2, 2, 2353, 2355, 10, 2, 2, 2, 2354, 2353, 3, 2, 2, 2, 2355, 2358, 3, 2, 2, 2, 2356, 2354, 3, 2, 2, 2, 2356, 2357, 3, 2, 2, 2, 2357, 2359, 3, 2, 2, 2, 2358, 2356, 3, 2, 2, 2, 2359, 2360, 7, 41, 2, 2, 2360, 516, 3, 2, 2, 2, 2361, 2363, 5, 539, 270, 2, 2362, 2361, 3, 2, 2, 2, 2363, 2364, 3, 2, 2, 2, 2364, 2362, 3, 2, 2, 2, 2364, 2365, 3, 2, 2, 2, 2365, 518, 3, 2, 2, 2, 2366, 2368, 5, 539, 270, 2, 2367, 2366, 3, 2, 2, 2, 2368, 2369, 3, 2, 2, 2, 2369, 2367, 3, 2, 2, 2, 2369, 2370, 3, 2, 2, 2, 2370, 2371, 3, 2, 2, 2, 2371, 2375, 7, 48, 2, 2, 2372, 2374, 5, 539, 270, 2, 2373, 2372, 3, 2, 2, 2, 2374, 2377, 3, 2, 2, 2, 2375, 2373, 3, 2, 2, 2, 2375, 2376, 3, 2, 2, 2, 2376, 2385, 3, 2, 2, 2, 2377, 2375, 3, 2, 2, 2, 2378, 2380, 7, 48, 2, 2, 2379, 2381, 5, 539, 270, 2, 2380, 2379, 3, 2, 2, 2, 2381, 2382, 3, 2, 2, 2, 2382, 2380, 3, 2, 2, 2, 2382, 2383, 3, 2, 2, 2, 2383, 2385, 3, 2, 2, 2, 2384, 2367, 3, 2, 2, 2, 2384, 2378, 3, 2, 2, 2, 2385, 520, 3, 2, 2, 2, 2386, 2388, 5, 539, 270, 2, 2387, 2386, 3, 2, 2, 2, 2388, 2389, 3, 2, 2, 2, 2389, 2387, 3, 2, 2, 2, 2389, 2390, 3, 2, 2, 2, 2390, 2398, 3, 2, 2, 2, 2391, 2395, 7, 48, 2, 2, 2392, 2394, 5, 539, 270, 2, 2393, 2392, 3, 2, 2, 2, 2394, 2397, 3, 2, 2, 2, 2395, 2393, 3, 2, 2, 2, 2395, 2396, 3, 2, 2, 2, 2396, 2399, 3, 2, 2, 2, 2397, 2395, 3, 2, 2, 2, 2398, 2391, 3, 2, 2, 2, 2398, 2399, 3, 2, 2, 2, 2399, 2400, 3, 2, 2, 2, 2400, 2401, 5, 537, 269, 2, 2401, 2411, 3, 2, 2, 2, 2402, 2404, 7, 48, 2, 2, 2403, 2405, 5, 539, 270, 2, 2404, 2403, 3, 2, 2, 2, 2405, 2406, 3, 2, 2, 2, 2406, 2404, 3, 2, 2, 2, 2406, 2407, 3, 2, 2, 2, 2407, 2408, 3, 2, 2, 2, 2408, 2409, 5, 537, 269, 2, 2409, 2411, 3, 2, 2, 2, 2410, 2387, 3, 2, 2, 2, 2410, 2402, 3, 2, 2, 2, 2411, 522, 3, 2, 2, 2, 2412, 2415, 5, 541, 271, 2, 2413, 2415, 7, 97, 2, 2, 2414, 2412, 3, 2, 2, 2, 2414, 2413, 3, 2, 2, 2, 2415, 2421, 3, 2, 2, 2, 2416, 2420, 5, 541, 271, 2, 2417, 2420, 5, 539, 270, 2, 2418, 2420, 9, 4, 2, 2, 2419, 2416, 3, 2, 2, 2, 2419, 2417, 3, 2, 2, 2, 2419, 2418, 3, 2, 2, 2, 2420, 2423, 3, 2, 2, 2, 2421, 2419, 3, 2, 2, 2, 2421, 2422, 3, 2, 2, 2, 2422, 524, 3, 2, 2, 2, 2423, 2421, 3, 2, 2, 2, 2424, 2428, 5, 539, 270, 2, 2425, 2429, 5, 541, 271, 2, 2426, 2429, 5, 539, 270, 2, 2427, 2429, 9, 4, 2, 2, 2428, 2425, 3, 2, 2, 2, 2428, 2426, 3, 2, 2, 2, 2428, 2427, 3, 2, 2, 2, 2429, 2430, 3, 2, 2, 2, 2430, 2428, 3, 2, 2, 2, 2430, 2431, 3, 2, 2, 2, 2431, 526, 3, 2, 2, 2, 2432, 2438, 7, 36, 2, 2, 2433, 2437, 10, 3, 2, 2, 2434, 2435, 7, 36, 2, 2, 2435, 2437, 7, 36, 2, 2, 2436, 2433, 3, 2, 2, 2, 2436, 2434, 3, 2, 2, 2, 2437, 2440, 3, 2, 2, 2, 2438, 2436, 3, 2, 2, 2, 2438, 2439, 3, 2, 2, 2, 2439, 2441, 3, 2, 2, 2, 2440, 2438, 3, 2, 2, 2, 2441, 2442, 7, 36, 2, 2, 2442, 528, 3, 2, 2, 2, 2443, 2449, 7, 98, 2, 2, 2444, 2448, 10, 5, 2, 2, 2445, 2446, 7, 98, 2, 2, 2446, 2448, 7, 98, 2, 2, 2447, 2444, 3, 2, 2, 2, 2447, 2445, 3, 2, 2, 2, 2448, 2451, 3, 2, 2, 2, 2449, 2447, 3, 2, 2, 2, 2449, 2450, 3, 2, 2, 2, 2450, 2452, 3, 2, 2, 2, 2451, 2449, 3, 2, 2, 2, 2452, 2453, 7, 98, 2, 2, 2453, 530, 3, 2, 2, 2, 2454, 2455, 7, 86, 2, 2, 2455, 2456, 7, 75, 2, 2, 2456, 2457, 7, 79, 2, 2, 2457, 2458, 7, 71, 2, 2, 2458, 2459, 3, 2, 2, 2, 2459, 2460, 5, 547, 274, 2, 2460, 2461, 7, 89, 2, 2, 2461, 2462, 7, 75, 2, 2, 2462, 2463, 7, 86, 2, 2, 2463, 2464, 7, 74, 2, 2, 2464, 2465, 3, 2, 2, 2, 2465, 2466, 5, 547, 274, 2, 2466, 2467, 7, 86, 2, 2, 2467, 2468, 7, 75, 2, 2, 2468, 2469, 7, 79, 2, 2, 2469, 2470, 7, 71, 2, 2, 2470, 2471, 3, 2, 2, 2, 2471, 2472, 5, 547, 274, 2, 2472, 2473, 7, 92, 2, 2, 2473, 2474, 7, 81, 2, 2, 2474, 2475, 7, 80, 2, 2, 2475, 2476, 7, 71, 2, 2, 2476, 532, 3, 2, 2, 2, 2477, 2478, 7, 86, 2, 2, 2478, 2479, 7, 75, 2, 2, 2479, 2480, 7, 79, 2, 2, 2480, 2481, 7, 71, 2, 2, 2481, 2482, 7, 85, 2, 2, 2482, 2483, 7, 86, 2, 2, 2483, 2484, 7, 67, 2, 2, 2484, 2485, 7, 79, 2, 2, 2485, 2486, 7, 82, 2, 2, 2486, 2487, 3, 2, 2, 2, 2487, 2488, 5, 547, 274, 2, 2488, 2489, 7, 89, 2, 2, 2489, 2490, 7, 75, 2, 2, 2490, 2491, 7, 86, 2, 2, 2491, 2492, 7, 74, 2, 2, 2492, 2493, 3, 2, 2, 2, 2493, 2494, 5, 547, 274, 2, 2494, 2495, 7, 86, 2, 2, 2495, 2496, 7, 75, 2, 2, 2496, 2497, 7, 79, 2, 2, 2497, 2498, 7, 71, 2, 2, 2498, 2499, 3, 2, 2, 2, 2499, 2500, 5, 547, 274, 2, 2500, 2501, 7, 92, 2, 2, 2501, 2502, 7, 81, 2, 2, 2502, 2503, 7, 80, 2, 2, 2503, 2504, 7, 71, 2, 2, 2504, 534, 3, 2, 2, 2, 2505, 2506, 7, 70, 2, 2, 2506, 2507, 7, 81, 2, 2, 2507, 2508, 7, 87, 2, 2, 2508, 2509, 7, 68, 2, 2, 2509, 2510, 7, 78, 2, 2, 2510, 2511, 7, 71, 2, 2, 2511, 2512, 3, 2, 2, 2, 2512, 2513, 5, 547, 274, 2, 2513, 2514, 7, 82, 2, 2, 2514, 2515, 7, 84, 2, 2, 2515, 2516, 7, 71, 2, 2, 2516, 2517, 7, 69, 2, 2, 2517, 2518, 7, 75, 2, 2, 2518, 2519, 7, 85, 2, 2, 2519, 2520, 7, 75, 2, 2, 2520, 2521, 7, 81, 2, 2, 2521, 2522, 7, 80, 2, 2, 2522, 536, 3, 2, 2, 2, 2523, 2525, 7, 71, 2, 2, 2524, 2526, 9, 6, 2, 2, 2525, 2524, 3, 2, 2, 2, 2525, 2526, 3, 2, 2, 2, 2526, 2528, 3, 2, 2, 2, 2527, 2529, 5, 539, 270, 2, 2528, 2527, 3, 2, 2, 2, 2529, 2530, 3, 2, 2, 2, 2530, 2528, 3, 2, 2, 2, 2530, 2531, 3, 2, 2, 2, 2531, 538, 3, 2, 2, 2, 2532, 2533, 9, 7, 2, 2, 2533, 540, 3, 2, 2, 2, 2534, 2535, 9, 8, 2, 2, 2535, 542, 3, 2, 2, 2, 2536, 2537, 7, 47, 2, 2, 2537, 2538, 7, 47, 2, 2, 2538, 2542, 3, 2, 2, 2, 2539, 2541, 10, 9, 2, 2, 2540, 2539, 3, 2, 2, 2, 2541, 2544, 3, 2, 2, 2, 2542, 2540, 3, 2, 2, 2, 2542, 2543, 3, 2, 2, 2, 2543, 2546, 3, 2, 2, 2, 2544, 2542, 3, 2, 2, 2, 2545, 2547, 7, 15, 2, 2, 2546, 2545, 3, 2, 2, 2, 2546, 2547, 3, 2, 2, 2, 2547, 2549, 3, 2, 2, 2, 2548, 2550, 7, 12, 2, 2, 2549, 2548, 3, 2, 2, 2, 2549, 2550, 3, 2, 2, 2, 2550, 2551, 3, 2, 2, 2, 2551, 2552, 8, 272, 2, 2, 2552, 544, 3, 2, 2, 2, 2553, 2554, 7, 49, 2, 2, 2554, 2555, 7, 44, 2, 2, 2555, 2559, 3, 2, 2, 2, 2556, 2558, 11, 2, 2, 2, 2557, 2556, 3, 2, 2, 2, 2558, 2561, 3, 2, 2, 2, 2559, 2560, 3, 2, 2, 2, 2559, 2557, 3, 2, 2, 2, 2560, 2562, 3, 2, 2, 2, 2561, 2559, 3, 2, 2, 2, 2562, 2563, 7, 44, 2, 2, 2563, 2564, 7, 49, 2, 2, 2564, 2565, 3, 2, 2, 2, 2565, 2566, 8, 273, 2, 2, 2566, 546, 3, 2, 2, 2, 2567, 2569, 9, 10, 2, 2, 2568, 2567, 3, 2, 2, 2, 2569, 2570, 3, 2, 2, 2, 2570, 2568, 3, 2, 2, 2, 2570, 2571, 3, 2, 2, 2, 2571, 2572, 3, 2, 2, 2, 2572, 2573, 8, 274, 2, 2, 2573, 548, 3, 2, 2, 2, 38, 2, 2262, 2318, 2320, 2328, 2330, 2334, 2343, 2345, 2356, 2364, 2369, 2375, 2382, 2384, 2389, 2395, 2398, 2406, 2410, 2414, 2419, 2421, 2428, 2430, 2436, 2438, 2447, 2449, 2525, 2530, 2542, 2546, 2549, 2559, 2570, 3, 2, 3, 2] \ No newline at end of file diff --git a/src/lib/impala/ImpalaSqlLexer.tokens b/src/lib/impala/ImpalaSqlLexer.tokens new file mode 100644 index 0000000..49c0108 --- /dev/null +++ b/src/lib/impala/ImpalaSqlLexer.tokens @@ -0,0 +1,523 @@ +KW_ADD=1 +KW_ALL=2 +KW_ANALYTIC=3 +KW_ALTER=4 +KW_AND=5 +KW_ANY=6 +KW_ANTI=7 +KW_ARRAY=8 +KW_AS=9 +KW_ASC=10 +KW_AT=11 +KW_AGGREGATE=12 +KW_AUTHORIZATION=13 +KW_BERNOULLI=14 +KW_BETWEEN=15 +KW_BLOCK_SIZE=16 +KW_PARTITIONED=17 +KW_PREPARE_FN=18 +KW_EXTERNAL=19 +KW_CLOSEFN=20 +KW_SORT=21 +KW_PURGE=22 +KW_STORED=23 +KW_LOCATION=24 +KW_TBLPROPERTIES=25 +KW_BY=26 +KW_CASCADE=27 +KW_CASE=28 +KW_CAST=29 +KW_CACHED=30 +KW_CHANGE=31 +KW_COLUMN=32 +KW_COLUMNS=33 +KW_COMMENT=34 +KW_COMPRESSION=35 +KW_COMPUTE=36 +KW_CREATE=37 +KW_CROSS=38 +KW_CURRENT=39 +KW_CURRENT_DATE=40 +KW_CURRENT_PATH=41 +KW_CURRENT_TIME=42 +KW_CURRENT_TIMESTAMP=43 +KW_CURRENT_USER=44 +KW_DATA=45 +KW_DATABASE=46 +KW_DATABASES=47 +KW_DAY=48 +KW_DAYS=49 +KW_DELETE=50 +KW_DEFAULT=51 +KW_DELIMITED=52 +KW_DISABLE=53 +KW_UPDATE=54 +KW_DESC=55 +KW_DESCRIBE=56 +KW_DISTINCT=57 +KW_DROP=58 +KW_ELSE=59 +KW_ENCODING=60 +KW_END=61 +KW_ESCAPE=62 +KW_ESCAPED=63 +KW_EXCEPT=64 +KW_EXCLUDING=65 +KW_EXISTS=66 +KW_EXPLAIN=67 +KW_EXTRACT=68 +KW_EXTENDED=69 +KW_FALSE=70 +KW_FIELDS=71 +KW_FILEFORMAT=72 +KW_FILES=73 +KW_FILTER=74 +KW_FIRST=75 +KW_FINALIZE_FN=76 +KW_FOLLOWING=77 +KW_FOR=78 +KW_FORMAT=79 +KW_FORMATTED=80 +KW_FOREIGN=81 +KW_FROM=82 +KW_FULL=83 +KW_FUNCTION=84 +KW_FUNCTIONS=85 +KW_GRANT=86 +KW_GROUP=87 +KW_GROUPING=88 +KW_HASH=89 +KW_HAVING=90 +KW_HOUR=91 +KW_HOURS=92 +KW_IF=93 +KW_IN=94 +KW_INCLUDING=95 +KW_INCREMENTAL=96 +KW_INNER=97 +KW_INPATH=98 +KW_INSERT=99 +KW_INTERSECT=100 +KW_INTERVAL=101 +KW_INTERMEDIATE=102 +KW_INTO=103 +KW_INIT_FN=104 +KW_INVALIDATE=105 +KW_IS=106 +KW_JOIN=107 +KW_KEY=108 +KW_KUDU=109 +KW_LAST=110 +KW_LATERAL=111 +KW_LEFT=112 +KW_LIKE=113 +KW_LIMIT=114 +KW_LINES=115 +KW_LOAD=116 +KW_LOCALTIME=117 +KW_LOCALTIMESTAMP=118 +KW_METADATA=119 +KW_MAP=120 +KW_MINUTE=121 +KW_MINUTES=122 +KW_MONTH=123 +KW_MONTHS=124 +KW_MERGE_FN=125 +KW_NFC=126 +KW_NFD=127 +KW_NFKC=128 +KW_NFKD=129 +KW_NORMALIZE=130 +KW_NOT=131 +KW_NULL=132 +KW_NULLS=133 +KW_OFFSET=134 +KW_ON=135 +KW_OPTION=136 +KW_OR=137 +KW_ORDER=138 +KW_ORDINALITY=139 +KW_OUTER=140 +KW_OWNER=141 +KW_OVER=142 +KW_OVERWRITE=143 +KW_PARTITION=144 +KW_PARTITIONS=145 +KW_PARQUET=146 +KW_POSITION=147 +KW_PRECEDING=148 +KW_PRIMARY=149 +KW_REPLICATION=150 +KW_PRIVILEGES=151 +KW_PROPERTIES=152 +KW_RANGE=153 +KW_RECOVER=154 +KW_RENAME=155 +KW_REPEATABLE=156 +KW_REPLACE=157 +KW_RESTRICT=158 +KW_RETURNS=159 +KW_REVOKE=160 +KW_REFRESH=161 +KW_REGEXP=162 +KW_RLIKE=163 +KW_RIGHT=164 +KW_ROLE=165 +KW_ROLES=166 +KW_ROW=167 +KW_ROWS=168 +KW_SCHEMA=169 +KW_SCHEMAS=170 +KW_SECOND=171 +KW_SECONDS=172 +KW_SELECT=173 +KW_SERDEPROPERTIES=174 +KW_SET=175 +KW_SEMI=176 +KW_SERVER=177 +KW_SHOW=178 +KW_SHUTDOWN=179 +KW_SOME=180 +KW_STATS=181 +KW_STRUCT=182 +KW_STRAIGHT_JOIN=183 +KW_SUBSTRING=184 +KW_SYSTEM=185 +KW_SYMBOL=186 +KW_SERIALIZE_FN=187 +KW_TABLE=188 +KW_TABLES=189 +KW_TABLESAMPLE=190 +KW_TERMINATED=191 +KW_THEN=192 +KW_TO=193 +KW_TRUE=194 +KW_TRY_CAST=195 +KW_TRUNCATE=196 +KW_UNCACHED=197 +KW_UESCAPE=198 +KW_UNBOUNDED=199 +KW_UNION=200 +KW_UNNEST=201 +KW_UNSET=202 +KW_USE=203 +KW_USER=204 +KW_USING=205 +KW_UPDATE_FN=206 +KW_UPSERT=207 +KW_URI=208 +KW_VALUE=209 +KW_VALUES=210 +KW_VIEW=211 +KW_VIEWS=212 +KW_WHEN=213 +KW_WHERE=214 +KW_WITH=215 +KW_YEAR=216 +KW_YEARS=217 +KW_TEXTFILE=218 +KW_ORC=219 +KW_AVRO=220 +KW_SEQUENCEFILE=221 +KW_RCFILE=222 +KW_REFERENCES=223 +KW_NOVALIDATE=224 +KW_RELY=225 +STATS_NUMDVS=226 +STATS_NUMNULLS=227 +STATS_AVGSIZE=228 +STATS_MAXSIZE=229 +EQ=230 +NEQ=231 +LT=232 +LTE=233 +GT=234 +GTE=235 +PLUS=236 +MINUS=237 +ASTERISK=238 +SLASH=239 +PERCENT=240 +CONCAT=241 +DOT=242 +SEMICOLON=243 +COMMA=244 +COLON=245 +LPAREN=246 +RPAREN=247 +LSQUARE=248 +RSQUARE=249 +LCURLY=250 +RCURLY=251 +BITWISEOR=252 +QUESTION=253 +RIGHT_ARROW=254 +STRING=255 +UNICODE_STRING=256 +BINARY_LITERAL=257 +INTEGER_VALUE=258 +DECIMAL_VALUE=259 +DOUBLE_VALUE=260 +IDENTIFIER=261 +DIGIT_IDENTIFIER=262 +QUOTED_IDENTIFIER=263 +BACKQUOTED_IDENTIFIER=264 +TIME_WITH_TIME_ZONE=265 +TIMESTAMP_WITH_TIME_ZONE=266 +DOUBLE_PRECISION=267 +SIMPLE_COMMENT=268 +BRACKETED_COMMENT=269 +WS=270 +'ADD'=1 +'ALL'=2 +'ANALYTIC'=3 +'ALTER'=4 +'AND'=5 +'ANY'=6 +'ANTI'=7 +'ARRAY'=8 +'AS'=9 +'ASC'=10 +'AT'=11 +'AGGREGATE'=12 +'AUTHORIZATION'=13 +'BERNOULLI'=14 +'BETWEEN'=15 +'BLOCK_SIZE'=16 +'PARTITIONED'=17 +'PREPARE_FN'=18 +'EXTERNAL'=19 +'CLOSEFN'=20 +'SORT'=21 +'PURGE'=22 +'STORED'=23 +'LOCATION'=24 +'TBLPROPERTIES'=25 +'BY'=26 +'CASCADE'=27 +'CASE'=28 +'CAST'=29 +'CACHED'=30 +'CHANGE'=31 +'COLUMN'=32 +'COLUMNS'=33 +'COMMENT'=34 +'COMPRESSION'=35 +'COMPUTE'=36 +'CREATE'=37 +'CROSS'=38 +'CURRENT'=39 +'CURRENT_DATE'=40 +'CURRENT_PATH'=41 +'CURRENT_TIME'=42 +'CURRENT_TIMESTAMP'=43 +'CURRENT_USER'=44 +'DATA'=45 +'DATABASE'=46 +'DATABASES'=47 +'DAY'=48 +'DAYS'=49 +'DELETE'=50 +'DEFAULT'=51 +'DELIMITED'=52 +'DISABLE'=53 +'UPDATE'=54 +'DESC'=55 +'DESCRIBE'=56 +'DISTINCT'=57 +'DROP'=58 +'ELSE'=59 +'ENCODING'=60 +'END'=61 +'ESCAPE'=62 +'ESCAPED'=63 +'EXCEPT'=64 +'EXCLUDING'=65 +'EXISTS'=66 +'EXPLAIN'=67 +'EXTRACT'=68 +'EXTENDED'=69 +'FALSE'=70 +'FIELDS'=71 +'FILEFORMAT'=72 +'FILES'=73 +'FILTER'=74 +'FIRST'=75 +'FINALIZE_FN'=76 +'FOLLOWING'=77 +'FOR'=78 +'FORMAT'=79 +'FORMATTED'=80 +'FOREIGN'=81 +'FROM'=82 +'FULL'=83 +'FUNCTION'=84 +'FUNCTIONS'=85 +'GRANT'=86 +'GROUP'=87 +'GROUPING'=88 +'HASH'=89 +'HAVING'=90 +'HOUR'=91 +'HOURS'=92 +'IF'=93 +'IN'=94 +'INCLUDING'=95 +'INCREMENTAL'=96 +'INNER'=97 +'INPATH'=98 +'INSERT'=99 +'INTERSECT'=100 +'INTERVAL'=101 +'INTERMEDIATE'=102 +'INTO'=103 +'INIT_FN'=104 +'INVALIDATE'=105 +'IS'=106 +'JOIN'=107 +'KEY'=108 +'KUDU'=109 +'LAST'=110 +'LATERAL'=111 +'LEFT'=112 +'LIKE'=113 +'LIMIT'=114 +'LINES'=115 +'LOAD'=116 +'LOCALTIME'=117 +'LOCALTIMESTAMP'=118 +'METADATA'=119 +'MAP'=120 +'MINUTE'=121 +'MINUTES'=122 +'MONTH'=123 +'MONTHS'=124 +'MERGE_FN'=125 +'NFC'=126 +'NFD'=127 +'NFKC'=128 +'NFKD'=129 +'NORMALIZE'=130 +'NOT'=131 +'NULL'=132 +'NULLS'=133 +'OFFSET'=134 +'ON'=135 +'OPTION'=136 +'OR'=137 +'ORDER'=138 +'ORDINALITY'=139 +'OUTER'=140 +'OWNER'=141 +'OVER'=142 +'OVERWRITE'=143 +'PARTITION'=144 +'PARTITIONS'=145 +'PARQUET'=146 +'POSITION'=147 +'PRECEDING'=148 +'PRIMARY'=149 +'REPLICATION'=150 +'PRIVILEGES'=151 +'PROPERTIES'=152 +'RANGE'=153 +'RECOVER'=154 +'RENAME'=155 +'REPEATABLE'=156 +'REPLACE'=157 +'RESTRICT'=158 +'RETURNS'=159 +'REVOKE'=160 +'REFRESH'=161 +'REGEXP'=162 +'RLIKE'=163 +'RIGHT'=164 +'ROLE'=165 +'ROLES'=166 +'ROW'=167 +'ROWS'=168 +'SCHEMA'=169 +'SCHEMAS'=170 +'SECOND'=171 +'SECONDS'=172 +'SELECT'=173 +'SERDEPROPERTIES'=174 +'SET'=175 +'SEMI'=176 +'SERVER'=177 +'SHOW'=178 +'SHUTDOWN'=179 +'SOME'=180 +'STATS'=181 +'STRUCT'=182 +'STRAIGHT_JOIN'=183 +'SUBSTRING'=184 +'SYSTEM'=185 +'SYMBOL'=186 +'SERIALIZE_FN'=187 +'TABLE'=188 +'TABLES'=189 +'TABLESAMPLE'=190 +'TERMINATED '=191 +'THEN'=192 +'TO'=193 +'TRUE'=194 +'TRY_CAST'=195 +'TRUNCATE'=196 +'UNCACHED'=197 +'UESCAPE'=198 +'UNBOUNDED'=199 +'UNION'=200 +'UNNEST'=201 +'UNSET'=202 +'USE'=203 +'USER'=204 +'USING'=205 +'UPDATE_FN'=206 +'UPSERT'=207 +'URI'=208 +'VALUE'=209 +'VALUES'=210 +'VIEW'=211 +'VIEWS'=212 +'WHEN'=213 +'WHERE'=214 +'WITH'=215 +'YEAR'=216 +'YEARS'=217 +'TEXTFILE'=218 +'ORC'=219 +'AVRO'=220 +'SEQUENCEFILE'=221 +'RCFILE'=222 +'REFERENCES'=223 +'NOVALIDATE'=224 +'RELY'=225 +'\'NUMDVS\''=226 +'\'NUMNULLS\''=227 +'\'AVGSIZE\''=228 +'\'MAXSIZE\''=229 +'='=230 +'<'=232 +'<='=233 +'>'=234 +'>='=235 +'+'=236 +'-'=237 +'*'=238 +'/'=239 +'%'=240 +'||'=241 +'.'=242 +';'=243 +','=244 +':'=245 +'('=246 +')'=247 +'['=248 +']'=249 +'{'=250 +'}'=251 +'|'=252 +'?'=253 +'->'=254 diff --git a/src/lib/impala/ImpalaSqlLexer.ts b/src/lib/impala/ImpalaSqlLexer.ts new file mode 100644 index 0000000..61355a3 --- /dev/null +++ b/src/lib/impala/ImpalaSqlLexer.ts @@ -0,0 +1,1749 @@ +// Generated from /Users/shuangxu/Documents/workspace/dt-sql-parser/src/grammar/impala/ImpalaSqlLexer.g4 by ANTLR 4.9.0-SNAPSHOT + + +import { ATN } from "antlr4ts/atn/ATN"; +import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer"; +import { CharStream } from "antlr4ts/CharStream"; +import { Lexer } from "antlr4ts/Lexer"; +import { LexerATNSimulator } from "antlr4ts/atn/LexerATNSimulator"; +import { NotNull } from "antlr4ts/Decorators"; +import { Override } from "antlr4ts/Decorators"; +import { RuleContext } from "antlr4ts/RuleContext"; +import { Vocabulary } from "antlr4ts/Vocabulary"; +import { VocabularyImpl } from "antlr4ts/VocabularyImpl"; + +import * as Utils from "antlr4ts/misc/Utils"; + + +export class ImpalaSqlLexer extends Lexer { + public static readonly KW_ADD = 1; + public static readonly KW_ALL = 2; + public static readonly KW_ANALYTIC = 3; + public static readonly KW_ALTER = 4; + public static readonly KW_AND = 5; + public static readonly KW_ANY = 6; + public static readonly KW_ANTI = 7; + public static readonly KW_ARRAY = 8; + public static readonly KW_AS = 9; + public static readonly KW_ASC = 10; + public static readonly KW_AT = 11; + public static readonly KW_AGGREGATE = 12; + public static readonly KW_AUTHORIZATION = 13; + public static readonly KW_BERNOULLI = 14; + public static readonly KW_BETWEEN = 15; + public static readonly KW_BLOCK_SIZE = 16; + public static readonly KW_PARTITIONED = 17; + public static readonly KW_PREPARE_FN = 18; + public static readonly KW_EXTERNAL = 19; + public static readonly KW_CLOSEFN = 20; + public static readonly KW_SORT = 21; + public static readonly KW_PURGE = 22; + public static readonly KW_STORED = 23; + public static readonly KW_LOCATION = 24; + public static readonly KW_TBLPROPERTIES = 25; + public static readonly KW_BY = 26; + public static readonly KW_CASCADE = 27; + public static readonly KW_CASE = 28; + public static readonly KW_CAST = 29; + public static readonly KW_CACHED = 30; + public static readonly KW_CHANGE = 31; + public static readonly KW_COLUMN = 32; + public static readonly KW_COLUMNS = 33; + public static readonly KW_COMMENT = 34; + public static readonly KW_COMPRESSION = 35; + public static readonly KW_COMPUTE = 36; + public static readonly KW_CREATE = 37; + public static readonly KW_CROSS = 38; + public static readonly KW_CURRENT = 39; + public static readonly KW_CURRENT_DATE = 40; + public static readonly KW_CURRENT_PATH = 41; + public static readonly KW_CURRENT_TIME = 42; + public static readonly KW_CURRENT_TIMESTAMP = 43; + public static readonly KW_CURRENT_USER = 44; + public static readonly KW_DATA = 45; + public static readonly KW_DATABASE = 46; + public static readonly KW_DATABASES = 47; + public static readonly KW_DAY = 48; + public static readonly KW_DAYS = 49; + public static readonly KW_DELETE = 50; + public static readonly KW_DEFAULT = 51; + public static readonly KW_DELIMITED = 52; + public static readonly KW_DISABLE = 53; + public static readonly KW_UPDATE = 54; + public static readonly KW_DESC = 55; + public static readonly KW_DESCRIBE = 56; + public static readonly KW_DISTINCT = 57; + public static readonly KW_DROP = 58; + public static readonly KW_ELSE = 59; + public static readonly KW_ENCODING = 60; + public static readonly KW_END = 61; + public static readonly KW_ESCAPE = 62; + public static readonly KW_ESCAPED = 63; + public static readonly KW_EXCEPT = 64; + public static readonly KW_EXCLUDING = 65; + public static readonly KW_EXISTS = 66; + public static readonly KW_EXPLAIN = 67; + public static readonly KW_EXTRACT = 68; + public static readonly KW_EXTENDED = 69; + public static readonly KW_FALSE = 70; + public static readonly KW_FIELDS = 71; + public static readonly KW_FILEFORMAT = 72; + public static readonly KW_FILES = 73; + public static readonly KW_FILTER = 74; + public static readonly KW_FIRST = 75; + public static readonly KW_FINALIZE_FN = 76; + public static readonly KW_FOLLOWING = 77; + public static readonly KW_FOR = 78; + public static readonly KW_FORMAT = 79; + public static readonly KW_FORMATTED = 80; + public static readonly KW_FOREIGN = 81; + public static readonly KW_FROM = 82; + public static readonly KW_FULL = 83; + public static readonly KW_FUNCTION = 84; + public static readonly KW_FUNCTIONS = 85; + public static readonly KW_GRANT = 86; + public static readonly KW_GROUP = 87; + public static readonly KW_GROUPING = 88; + public static readonly KW_HASH = 89; + public static readonly KW_HAVING = 90; + public static readonly KW_HOUR = 91; + public static readonly KW_HOURS = 92; + public static readonly KW_IF = 93; + public static readonly KW_IN = 94; + public static readonly KW_INCLUDING = 95; + public static readonly KW_INCREMENTAL = 96; + public static readonly KW_INNER = 97; + public static readonly KW_INPATH = 98; + public static readonly KW_INSERT = 99; + public static readonly KW_INTERSECT = 100; + public static readonly KW_INTERVAL = 101; + public static readonly KW_INTERMEDIATE = 102; + public static readonly KW_INTO = 103; + public static readonly KW_INIT_FN = 104; + public static readonly KW_INVALIDATE = 105; + public static readonly KW_IS = 106; + public static readonly KW_JOIN = 107; + public static readonly KW_KEY = 108; + public static readonly KW_KUDU = 109; + public static readonly KW_LAST = 110; + public static readonly KW_LATERAL = 111; + public static readonly KW_LEFT = 112; + public static readonly KW_LIKE = 113; + public static readonly KW_LIMIT = 114; + public static readonly KW_LINES = 115; + public static readonly KW_LOAD = 116; + public static readonly KW_LOCALTIME = 117; + public static readonly KW_LOCALTIMESTAMP = 118; + public static readonly KW_METADATA = 119; + public static readonly KW_MAP = 120; + public static readonly KW_MINUTE = 121; + public static readonly KW_MINUTES = 122; + public static readonly KW_MONTH = 123; + public static readonly KW_MONTHS = 124; + public static readonly KW_MERGE_FN = 125; + public static readonly KW_NFC = 126; + public static readonly KW_NFD = 127; + public static readonly KW_NFKC = 128; + public static readonly KW_NFKD = 129; + public static readonly KW_NORMALIZE = 130; + public static readonly KW_NOT = 131; + public static readonly KW_NULL = 132; + public static readonly KW_NULLS = 133; + public static readonly KW_OFFSET = 134; + public static readonly KW_ON = 135; + public static readonly KW_OPTION = 136; + public static readonly KW_OR = 137; + public static readonly KW_ORDER = 138; + public static readonly KW_ORDINALITY = 139; + public static readonly KW_OUTER = 140; + public static readonly KW_OWNER = 141; + public static readonly KW_OVER = 142; + public static readonly KW_OVERWRITE = 143; + public static readonly KW_PARTITION = 144; + public static readonly KW_PARTITIONS = 145; + public static readonly KW_PARQUET = 146; + public static readonly KW_POSITION = 147; + public static readonly KW_PRECEDING = 148; + public static readonly KW_PRIMARY = 149; + public static readonly KW_REPLICATION = 150; + public static readonly KW_PRIVILEGES = 151; + public static readonly KW_PROPERTIES = 152; + public static readonly KW_RANGE = 153; + public static readonly KW_RECOVER = 154; + public static readonly KW_RENAME = 155; + public static readonly KW_REPEATABLE = 156; + public static readonly KW_REPLACE = 157; + public static readonly KW_RESTRICT = 158; + public static readonly KW_RETURNS = 159; + public static readonly KW_REVOKE = 160; + public static readonly KW_REFRESH = 161; + public static readonly KW_REGEXP = 162; + public static readonly KW_RLIKE = 163; + public static readonly KW_RIGHT = 164; + public static readonly KW_ROLE = 165; + public static readonly KW_ROLES = 166; + public static readonly KW_ROW = 167; + public static readonly KW_ROWS = 168; + public static readonly KW_SCHEMA = 169; + public static readonly KW_SCHEMAS = 170; + public static readonly KW_SECOND = 171; + public static readonly KW_SECONDS = 172; + public static readonly KW_SELECT = 173; + public static readonly KW_SERDEPROPERTIES = 174; + public static readonly KW_SET = 175; + public static readonly KW_SEMI = 176; + public static readonly KW_SERVER = 177; + public static readonly KW_SHOW = 178; + public static readonly KW_SHUTDOWN = 179; + public static readonly KW_SOME = 180; + public static readonly KW_STATS = 181; + public static readonly KW_STRUCT = 182; + public static readonly KW_STRAIGHT_JOIN = 183; + public static readonly KW_SUBSTRING = 184; + public static readonly KW_SYSTEM = 185; + public static readonly KW_SYMBOL = 186; + public static readonly KW_SERIALIZE_FN = 187; + public static readonly KW_TABLE = 188; + public static readonly KW_TABLES = 189; + public static readonly KW_TABLESAMPLE = 190; + public static readonly KW_TERMINATED = 191; + public static readonly KW_THEN = 192; + public static readonly KW_TO = 193; + public static readonly KW_TRUE = 194; + public static readonly KW_TRY_CAST = 195; + public static readonly KW_TRUNCATE = 196; + public static readonly KW_UNCACHED = 197; + public static readonly KW_UESCAPE = 198; + public static readonly KW_UNBOUNDED = 199; + public static readonly KW_UNION = 200; + public static readonly KW_UNNEST = 201; + public static readonly KW_UNSET = 202; + public static readonly KW_USE = 203; + public static readonly KW_USER = 204; + public static readonly KW_USING = 205; + public static readonly KW_UPDATE_FN = 206; + public static readonly KW_UPSERT = 207; + public static readonly KW_URI = 208; + public static readonly KW_VALUE = 209; + public static readonly KW_VALUES = 210; + public static readonly KW_VIEW = 211; + public static readonly KW_VIEWS = 212; + public static readonly KW_WHEN = 213; + public static readonly KW_WHERE = 214; + public static readonly KW_WITH = 215; + public static readonly KW_YEAR = 216; + public static readonly KW_YEARS = 217; + public static readonly KW_TEXTFILE = 218; + public static readonly KW_ORC = 219; + public static readonly KW_AVRO = 220; + public static readonly KW_SEQUENCEFILE = 221; + public static readonly KW_RCFILE = 222; + public static readonly KW_REFERENCES = 223; + public static readonly KW_NOVALIDATE = 224; + public static readonly KW_RELY = 225; + public static readonly STATS_NUMDVS = 226; + public static readonly STATS_NUMNULLS = 227; + public static readonly STATS_AVGSIZE = 228; + public static readonly STATS_MAXSIZE = 229; + public static readonly EQ = 230; + public static readonly NEQ = 231; + public static readonly LT = 232; + public static readonly LTE = 233; + public static readonly GT = 234; + public static readonly GTE = 235; + public static readonly PLUS = 236; + public static readonly MINUS = 237; + public static readonly ASTERISK = 238; + public static readonly SLASH = 239; + public static readonly PERCENT = 240; + public static readonly CONCAT = 241; + public static readonly DOT = 242; + public static readonly SEMICOLON = 243; + public static readonly COMMA = 244; + public static readonly COLON = 245; + public static readonly LPAREN = 246; + public static readonly RPAREN = 247; + public static readonly LSQUARE = 248; + public static readonly RSQUARE = 249; + public static readonly LCURLY = 250; + public static readonly RCURLY = 251; + public static readonly BITWISEOR = 252; + public static readonly QUESTION = 253; + public static readonly RIGHT_ARROW = 254; + public static readonly STRING = 255; + public static readonly UNICODE_STRING = 256; + public static readonly BINARY_LITERAL = 257; + public static readonly INTEGER_VALUE = 258; + public static readonly DECIMAL_VALUE = 259; + public static readonly DOUBLE_VALUE = 260; + public static readonly IDENTIFIER = 261; + public static readonly DIGIT_IDENTIFIER = 262; + public static readonly QUOTED_IDENTIFIER = 263; + public static readonly BACKQUOTED_IDENTIFIER = 264; + public static readonly TIME_WITH_TIME_ZONE = 265; + public static readonly TIMESTAMP_WITH_TIME_ZONE = 266; + public static readonly DOUBLE_PRECISION = 267; + public static readonly SIMPLE_COMMENT = 268; + public static readonly BRACKETED_COMMENT = 269; + public static readonly WS = 270; + + // tslint:disable:no-trailing-whitespace + public static readonly channelNames: string[] = [ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", + ]; + + // tslint:disable:no-trailing-whitespace + public static readonly modeNames: string[] = [ + "DEFAULT_MODE", + ]; + + public static readonly ruleNames: string[] = [ + "KW_ADD", "KW_ALL", "KW_ANALYTIC", "KW_ALTER", "KW_AND", "KW_ANY", "KW_ANTI", + "KW_ARRAY", "KW_AS", "KW_ASC", "KW_AT", "KW_AGGREGATE", "KW_AUTHORIZATION", + "KW_BERNOULLI", "KW_BETWEEN", "KW_BLOCK_SIZE", "KW_PARTITIONED", "KW_PREPARE_FN", + "KW_EXTERNAL", "KW_CLOSEFN", "KW_SORT", "KW_PURGE", "KW_STORED", "KW_LOCATION", + "KW_TBLPROPERTIES", "KW_BY", "KW_CASCADE", "KW_CASE", "KW_CAST", "KW_CACHED", + "KW_CHANGE", "KW_COLUMN", "KW_COLUMNS", "KW_COMMENT", "KW_COMPRESSION", + "KW_COMPUTE", "KW_CREATE", "KW_CROSS", "KW_CURRENT", "KW_CURRENT_DATE", + "KW_CURRENT_PATH", "KW_CURRENT_TIME", "KW_CURRENT_TIMESTAMP", "KW_CURRENT_USER", + "KW_DATA", "KW_DATABASE", "KW_DATABASES", "KW_DAY", "KW_DAYS", "KW_DELETE", + "KW_DEFAULT", "KW_DELIMITED", "KW_DISABLE", "KW_UPDATE", "KW_DESC", "KW_DESCRIBE", + "KW_DISTINCT", "KW_DROP", "KW_ELSE", "KW_ENCODING", "KW_END", "KW_ESCAPE", + "KW_ESCAPED", "KW_EXCEPT", "KW_EXCLUDING", "KW_EXISTS", "KW_EXPLAIN", + "KW_EXTRACT", "KW_EXTENDED", "KW_FALSE", "KW_FIELDS", "KW_FILEFORMAT", + "KW_FILES", "KW_FILTER", "KW_FIRST", "KW_FINALIZE_FN", "KW_FOLLOWING", + "KW_FOR", "KW_FORMAT", "KW_FORMATTED", "KW_FOREIGN", "KW_FROM", "KW_FULL", + "KW_FUNCTION", "KW_FUNCTIONS", "KW_GRANT", "KW_GROUP", "KW_GROUPING", + "KW_HASH", "KW_HAVING", "KW_HOUR", "KW_HOURS", "KW_IF", "KW_IN", "KW_INCLUDING", + "KW_INCREMENTAL", "KW_INNER", "KW_INPATH", "KW_INSERT", "KW_INTERSECT", + "KW_INTERVAL", "KW_INTERMEDIATE", "KW_INTO", "KW_INIT_FN", "KW_INVALIDATE", + "KW_IS", "KW_JOIN", "KW_KEY", "KW_KUDU", "KW_LAST", "KW_LATERAL", "KW_LEFT", + "KW_LIKE", "KW_LIMIT", "KW_LINES", "KW_LOAD", "KW_LOCALTIME", "KW_LOCALTIMESTAMP", + "KW_METADATA", "KW_MAP", "KW_MINUTE", "KW_MINUTES", "KW_MONTH", "KW_MONTHS", + "KW_MERGE_FN", "KW_NFC", "KW_NFD", "KW_NFKC", "KW_NFKD", "KW_NORMALIZE", + "KW_NOT", "KW_NULL", "KW_NULLS", "KW_OFFSET", "KW_ON", "KW_OPTION", "KW_OR", + "KW_ORDER", "KW_ORDINALITY", "KW_OUTER", "KW_OWNER", "KW_OVER", "KW_OVERWRITE", + "KW_PARTITION", "KW_PARTITIONS", "KW_PARQUET", "KW_POSITION", "KW_PRECEDING", + "KW_PRIMARY", "KW_REPLICATION", "KW_PRIVILEGES", "KW_PROPERTIES", "KW_RANGE", + "KW_RECOVER", "KW_RENAME", "KW_REPEATABLE", "KW_REPLACE", "KW_RESTRICT", + "KW_RETURNS", "KW_REVOKE", "KW_REFRESH", "KW_REGEXP", "KW_RLIKE", "KW_RIGHT", + "KW_ROLE", "KW_ROLES", "KW_ROW", "KW_ROWS", "KW_SCHEMA", "KW_SCHEMAS", + "KW_SECOND", "KW_SECONDS", "KW_SELECT", "KW_SERDEPROPERTIES", "KW_SET", + "KW_SEMI", "KW_SERVER", "KW_SHOW", "KW_SHUTDOWN", "KW_SOME", "KW_STATS", + "KW_STRUCT", "KW_STRAIGHT_JOIN", "KW_SUBSTRING", "KW_SYSTEM", "KW_SYMBOL", + "KW_SERIALIZE_FN", "KW_TABLE", "KW_TABLES", "KW_TABLESAMPLE", "KW_TERMINATED", + "KW_THEN", "KW_TO", "KW_TRUE", "KW_TRY_CAST", "KW_TRUNCATE", "KW_UNCACHED", + "KW_UESCAPE", "KW_UNBOUNDED", "KW_UNION", "KW_UNNEST", "KW_UNSET", "KW_USE", + "KW_USER", "KW_USING", "KW_UPDATE_FN", "KW_UPSERT", "KW_URI", "KW_VALUE", + "KW_VALUES", "KW_VIEW", "KW_VIEWS", "KW_WHEN", "KW_WHERE", "KW_WITH", + "KW_YEAR", "KW_YEARS", "KW_TEXTFILE", "KW_ORC", "KW_AVRO", "KW_SEQUENCEFILE", + "KW_RCFILE", "KW_REFERENCES", "KW_NOVALIDATE", "KW_RELY", "STATS_NUMDVS", + "STATS_NUMNULLS", "STATS_AVGSIZE", "STATS_MAXSIZE", "EQ", "NEQ", "LT", + "LTE", "GT", "GTE", "PLUS", "MINUS", "ASTERISK", "SLASH", "PERCENT", "CONCAT", + "DOT", "SEMICOLON", "COMMA", "COLON", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", + "LCURLY", "RCURLY", "BITWISEOR", "QUESTION", "RIGHT_ARROW", "STRING", + "UNICODE_STRING", "BINARY_LITERAL", "INTEGER_VALUE", "DECIMAL_VALUE", + "DOUBLE_VALUE", "IDENTIFIER", "DIGIT_IDENTIFIER", "QUOTED_IDENTIFIER", + "BACKQUOTED_IDENTIFIER", "TIME_WITH_TIME_ZONE", "TIMESTAMP_WITH_TIME_ZONE", + "DOUBLE_PRECISION", "EXPONENT", "DIGIT", "LETTER", "SIMPLE_COMMENT", "BRACKETED_COMMENT", + "WS", + ]; + + private static readonly _LITERAL_NAMES: Array = [ + undefined, "'ADD'", "'ALL'", "'ANALYTIC'", "'ALTER'", "'AND'", "'ANY'", + "'ANTI'", "'ARRAY'", "'AS'", "'ASC'", "'AT'", "'AGGREGATE'", "'AUTHORIZATION'", + "'BERNOULLI'", "'BETWEEN'", "'BLOCK_SIZE'", "'PARTITIONED'", "'PREPARE_FN'", + "'EXTERNAL'", "'CLOSEFN'", "'SORT'", "'PURGE'", "'STORED'", "'LOCATION'", + "'TBLPROPERTIES'", "'BY'", "'CASCADE'", "'CASE'", "'CAST'", "'CACHED'", + "'CHANGE'", "'COLUMN'", "'COLUMNS'", "'COMMENT'", "'COMPRESSION'", "'COMPUTE'", + "'CREATE'", "'CROSS'", "'CURRENT'", "'CURRENT_DATE'", "'CURRENT_PATH'", + "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", "'CURRENT_USER'", "'DATA'", "'DATABASE'", + "'DATABASES'", "'DAY'", "'DAYS'", "'DELETE'", "'DEFAULT'", "'DELIMITED'", + "'DISABLE'", "'UPDATE'", "'DESC'", "'DESCRIBE'", "'DISTINCT'", "'DROP'", + "'ELSE'", "'ENCODING'", "'END'", "'ESCAPE'", "'ESCAPED'", "'EXCEPT'", + "'EXCLUDING'", "'EXISTS'", "'EXPLAIN'", "'EXTRACT'", "'EXTENDED'", "'FALSE'", + "'FIELDS'", "'FILEFORMAT'", "'FILES'", "'FILTER'", "'FIRST'", "'FINALIZE_FN'", + "'FOLLOWING'", "'FOR'", "'FORMAT'", "'FORMATTED'", "'FOREIGN'", "'FROM'", + "'FULL'", "'FUNCTION'", "'FUNCTIONS'", "'GRANT'", "'GROUP'", "'GROUPING'", + "'HASH'", "'HAVING'", "'HOUR'", "'HOURS'", "'IF'", "'IN'", "'INCLUDING'", + "'INCREMENTAL'", "'INNER'", "'INPATH'", "'INSERT'", "'INTERSECT'", "'INTERVAL'", + "'INTERMEDIATE'", "'INTO'", "'INIT_FN'", "'INVALIDATE'", "'IS'", "'JOIN'", + "'KEY'", "'KUDU'", "'LAST'", "'LATERAL'", "'LEFT'", "'LIKE'", "'LIMIT'", + "'LINES'", "'LOAD'", "'LOCALTIME'", "'LOCALTIMESTAMP'", "'METADATA'", + "'MAP'", "'MINUTE'", "'MINUTES'", "'MONTH'", "'MONTHS'", "'MERGE_FN'", + "'NFC'", "'NFD'", "'NFKC'", "'NFKD'", "'NORMALIZE'", "'NOT'", "'NULL'", + "'NULLS'", "'OFFSET'", "'ON'", "'OPTION'", "'OR'", "'ORDER'", "'ORDINALITY'", + "'OUTER'", "'OWNER'", "'OVER'", "'OVERWRITE'", "'PARTITION'", "'PARTITIONS'", + "'PARQUET'", "'POSITION'", "'PRECEDING'", "'PRIMARY'", "'REPLICATION'", + "'PRIVILEGES'", "'PROPERTIES'", "'RANGE'", "'RECOVER'", "'RENAME'", "'REPEATABLE'", + "'REPLACE'", "'RESTRICT'", "'RETURNS'", "'REVOKE'", "'REFRESH'", "'REGEXP'", + "'RLIKE'", "'RIGHT'", "'ROLE'", "'ROLES'", "'ROW'", "'ROWS'", "'SCHEMA'", + "'SCHEMAS'", "'SECOND'", "'SECONDS'", "'SELECT'", "'SERDEPROPERTIES'", + "'SET'", "'SEMI'", "'SERVER'", "'SHOW'", "'SHUTDOWN'", "'SOME'", "'STATS'", + "'STRUCT'", "'STRAIGHT_JOIN'", "'SUBSTRING'", "'SYSTEM'", "'SYMBOL'", + "'SERIALIZE_FN'", "'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TERMINATED '", + "'THEN'", "'TO'", "'TRUE'", "'TRY_CAST'", "'TRUNCATE'", "'UNCACHED'", + "'UESCAPE'", "'UNBOUNDED'", "'UNION'", "'UNNEST'", "'UNSET'", "'USE'", + "'USER'", "'USING'", "'UPDATE_FN'", "'UPSERT'", "'URI'", "'VALUE'", "'VALUES'", + "'VIEW'", "'VIEWS'", "'WHEN'", "'WHERE'", "'WITH'", "'YEAR'", "'YEARS'", + "'TEXTFILE'", "'ORC'", "'AVRO'", "'SEQUENCEFILE'", "'RCFILE'", "'REFERENCES'", + "'NOVALIDATE'", "'RELY'", "''UMDVS''", "''UMNULLS''", "''VGSIZE''", "''AXSIZE''", + "'='", undefined, "'<'", "'<='", "'>'", "'>='", "'+'", "'-'", "'*'", "'/'", + "'%'", "'||'", "'.'", "';'", "','", "':'", "'('", "')'", "'['", "']'", + "'{'", "'}'", "'|'", "'?'", "'->'", + ]; + private static readonly _SYMBOLIC_NAMES: Array = [ + undefined, "KW_ADD", "KW_ALL", "KW_ANALYTIC", "KW_ALTER", "KW_AND", "KW_ANY", + "KW_ANTI", "KW_ARRAY", "KW_AS", "KW_ASC", "KW_AT", "KW_AGGREGATE", "KW_AUTHORIZATION", + "KW_BERNOULLI", "KW_BETWEEN", "KW_BLOCK_SIZE", "KW_PARTITIONED", "KW_PREPARE_FN", + "KW_EXTERNAL", "KW_CLOSEFN", "KW_SORT", "KW_PURGE", "KW_STORED", "KW_LOCATION", + "KW_TBLPROPERTIES", "KW_BY", "KW_CASCADE", "KW_CASE", "KW_CAST", "KW_CACHED", + "KW_CHANGE", "KW_COLUMN", "KW_COLUMNS", "KW_COMMENT", "KW_COMPRESSION", + "KW_COMPUTE", "KW_CREATE", "KW_CROSS", "KW_CURRENT", "KW_CURRENT_DATE", + "KW_CURRENT_PATH", "KW_CURRENT_TIME", "KW_CURRENT_TIMESTAMP", "KW_CURRENT_USER", + "KW_DATA", "KW_DATABASE", "KW_DATABASES", "KW_DAY", "KW_DAYS", "KW_DELETE", + "KW_DEFAULT", "KW_DELIMITED", "KW_DISABLE", "KW_UPDATE", "KW_DESC", "KW_DESCRIBE", + "KW_DISTINCT", "KW_DROP", "KW_ELSE", "KW_ENCODING", "KW_END", "KW_ESCAPE", + "KW_ESCAPED", "KW_EXCEPT", "KW_EXCLUDING", "KW_EXISTS", "KW_EXPLAIN", + "KW_EXTRACT", "KW_EXTENDED", "KW_FALSE", "KW_FIELDS", "KW_FILEFORMAT", + "KW_FILES", "KW_FILTER", "KW_FIRST", "KW_FINALIZE_FN", "KW_FOLLOWING", + "KW_FOR", "KW_FORMAT", "KW_FORMATTED", "KW_FOREIGN", "KW_FROM", "KW_FULL", + "KW_FUNCTION", "KW_FUNCTIONS", "KW_GRANT", "KW_GROUP", "KW_GROUPING", + "KW_HASH", "KW_HAVING", "KW_HOUR", "KW_HOURS", "KW_IF", "KW_IN", "KW_INCLUDING", + "KW_INCREMENTAL", "KW_INNER", "KW_INPATH", "KW_INSERT", "KW_INTERSECT", + "KW_INTERVAL", "KW_INTERMEDIATE", "KW_INTO", "KW_INIT_FN", "KW_INVALIDATE", + "KW_IS", "KW_JOIN", "KW_KEY", "KW_KUDU", "KW_LAST", "KW_LATERAL", "KW_LEFT", + "KW_LIKE", "KW_LIMIT", "KW_LINES", "KW_LOAD", "KW_LOCALTIME", "KW_LOCALTIMESTAMP", + "KW_METADATA", "KW_MAP", "KW_MINUTE", "KW_MINUTES", "KW_MONTH", "KW_MONTHS", + "KW_MERGE_FN", "KW_NFC", "KW_NFD", "KW_NFKC", "KW_NFKD", "KW_NORMALIZE", + "KW_NOT", "KW_NULL", "KW_NULLS", "KW_OFFSET", "KW_ON", "KW_OPTION", "KW_OR", + "KW_ORDER", "KW_ORDINALITY", "KW_OUTER", "KW_OWNER", "KW_OVER", "KW_OVERWRITE", + "KW_PARTITION", "KW_PARTITIONS", "KW_PARQUET", "KW_POSITION", "KW_PRECEDING", + "KW_PRIMARY", "KW_REPLICATION", "KW_PRIVILEGES", "KW_PROPERTIES", "KW_RANGE", + "KW_RECOVER", "KW_RENAME", "KW_REPEATABLE", "KW_REPLACE", "KW_RESTRICT", + "KW_RETURNS", "KW_REVOKE", "KW_REFRESH", "KW_REGEXP", "KW_RLIKE", "KW_RIGHT", + "KW_ROLE", "KW_ROLES", "KW_ROW", "KW_ROWS", "KW_SCHEMA", "KW_SCHEMAS", + "KW_SECOND", "KW_SECONDS", "KW_SELECT", "KW_SERDEPROPERTIES", "KW_SET", + "KW_SEMI", "KW_SERVER", "KW_SHOW", "KW_SHUTDOWN", "KW_SOME", "KW_STATS", + "KW_STRUCT", "KW_STRAIGHT_JOIN", "KW_SUBSTRING", "KW_SYSTEM", "KW_SYMBOL", + "KW_SERIALIZE_FN", "KW_TABLE", "KW_TABLES", "KW_TABLESAMPLE", "KW_TERMINATED", + "KW_THEN", "KW_TO", "KW_TRUE", "KW_TRY_CAST", "KW_TRUNCATE", "KW_UNCACHED", + "KW_UESCAPE", "KW_UNBOUNDED", "KW_UNION", "KW_UNNEST", "KW_UNSET", "KW_USE", + "KW_USER", "KW_USING", "KW_UPDATE_FN", "KW_UPSERT", "KW_URI", "KW_VALUE", + "KW_VALUES", "KW_VIEW", "KW_VIEWS", "KW_WHEN", "KW_WHERE", "KW_WITH", + "KW_YEAR", "KW_YEARS", "KW_TEXTFILE", "KW_ORC", "KW_AVRO", "KW_SEQUENCEFILE", + "KW_RCFILE", "KW_REFERENCES", "KW_NOVALIDATE", "KW_RELY", "STATS_NUMDVS", + "STATS_NUMNULLS", "STATS_AVGSIZE", "STATS_MAXSIZE", "EQ", "NEQ", "LT", + "LTE", "GT", "GTE", "PLUS", "MINUS", "ASTERISK", "SLASH", "PERCENT", "CONCAT", + "DOT", "SEMICOLON", "COMMA", "COLON", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", + "LCURLY", "RCURLY", "BITWISEOR", "QUESTION", "RIGHT_ARROW", "STRING", + "UNICODE_STRING", "BINARY_LITERAL", "INTEGER_VALUE", "DECIMAL_VALUE", + "DOUBLE_VALUE", "IDENTIFIER", "DIGIT_IDENTIFIER", "QUOTED_IDENTIFIER", + "BACKQUOTED_IDENTIFIER", "TIME_WITH_TIME_ZONE", "TIMESTAMP_WITH_TIME_ZONE", + "DOUBLE_PRECISION", "SIMPLE_COMMENT", "BRACKETED_COMMENT", "WS", + ]; + public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(ImpalaSqlLexer._LITERAL_NAMES, ImpalaSqlLexer._SYMBOLIC_NAMES, []); + + // @Override + // @NotNull + public get vocabulary(): Vocabulary { + return ImpalaSqlLexer.VOCABULARY; + } + // tslint:enable:no-trailing-whitespace + + + constructor(input: CharStream) { + super(input); + this._interp = new LexerATNSimulator(ImpalaSqlLexer._ATN, this); + } + + // @Override + public get grammarFileName(): string { return "ImpalaSqlLexer.g4"; } + + // @Override + public get ruleNames(): string[] { return ImpalaSqlLexer.ruleNames; } + + // @Override + public get serializedATN(): string { return ImpalaSqlLexer._serializedATN; } + + // @Override + public get channelNames(): string[] { return ImpalaSqlLexer.channelNames; } + + // @Override + public get modeNames(): string[] { return ImpalaSqlLexer.modeNames; } + + private static readonly _serializedATNSegments: number = 5; + private static readonly _serializedATNSegment0: string = + "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x02\u0110\u0A0E\b" + + "\x01\x04\x02\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t" + + "\x06\x04\x07\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04" + + "\r\t\r\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12" + + "\t\x12\x04\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17" + + "\t\x17\x04\x18\t\x18\x04\x19\t\x19\x04\x1A\t\x1A\x04\x1B\t\x1B\x04\x1C" + + "\t\x1C\x04\x1D\t\x1D\x04\x1E\t\x1E\x04\x1F\t\x1F\x04 \t \x04!\t!\x04\"" + + "\t\"\x04#\t#\x04$\t$\x04%\t%\x04&\t&\x04\'\t\'\x04(\t(\x04)\t)\x04*\t" + + "*\x04+\t+\x04,\t,\x04-\t-\x04.\t.\x04/\t/\x040\t0\x041\t1\x042\t2\x04" + + "3\t3\x044\t4\x045\t5\x046\t6\x047\t7\x048\t8\x049\t9\x04:\t:\x04;\t;\x04" + + "<\t<\x04=\t=\x04>\t>\x04?\t?\x04@\t@\x04A\tA\x04B\tB\x04C\tC\x04D\tD\x04" + + "E\tE\x04F\tF\x04G\tG\x04H\tH\x04I\tI\x04J\tJ\x04K\tK\x04L\tL\x04M\tM\x04" + + "N\tN\x04O\tO\x04P\tP\x04Q\tQ\x04R\tR\x04S\tS\x04T\tT\x04U\tU\x04V\tV\x04" + + "W\tW\x04X\tX\x04Y\tY\x04Z\tZ\x04[\t[\x04\\\t\\\x04]\t]\x04^\t^\x04_\t" + + "_\x04`\t`\x04a\ta\x04b\tb\x04c\tc\x04d\td\x04e\te\x04f\tf\x04g\tg\x04" + + "h\th\x04i\ti\x04j\tj\x04k\tk\x04l\tl\x04m\tm\x04n\tn\x04o\to\x04p\tp\x04" + + "q\tq\x04r\tr\x04s\ts\x04t\tt\x04u\tu\x04v\tv\x04w\tw\x04x\tx\x04y\ty\x04" + + "z\tz\x04{\t{\x04|\t|\x04}\t}\x04~\t~\x04\x7F\t\x7F\x04\x80\t\x80\x04\x81" + + "\t\x81\x04\x82\t\x82\x04\x83\t\x83\x04\x84\t\x84\x04\x85\t\x85\x04\x86" + + "\t\x86\x04\x87\t\x87\x04\x88\t\x88\x04\x89\t\x89\x04\x8A\t\x8A\x04\x8B" + + "\t\x8B\x04\x8C\t\x8C\x04\x8D\t\x8D\x04\x8E\t\x8E\x04\x8F\t\x8F\x04\x90" + + "\t\x90\x04\x91\t\x91\x04\x92\t\x92\x04\x93\t\x93\x04\x94\t\x94\x04\x95" + + "\t\x95\x04\x96\t\x96\x04\x97\t\x97\x04\x98\t\x98\x04\x99\t\x99\x04\x9A" + + "\t\x9A\x04\x9B\t\x9B\x04\x9C\t\x9C\x04\x9D\t\x9D\x04\x9E\t\x9E\x04\x9F" + + "\t\x9F\x04\xA0\t\xA0\x04\xA1\t\xA1\x04\xA2\t\xA2\x04\xA3\t\xA3\x04\xA4" + + "\t\xA4\x04\xA5\t\xA5\x04\xA6\t\xA6\x04\xA7\t\xA7\x04\xA8\t\xA8\x04\xA9" + + "\t\xA9\x04\xAA\t\xAA\x04\xAB\t\xAB\x04\xAC\t\xAC\x04\xAD\t\xAD\x04\xAE" + + "\t\xAE\x04\xAF\t\xAF\x04\xB0\t\xB0\x04\xB1\t\xB1\x04\xB2\t\xB2\x04\xB3" + + "\t\xB3\x04\xB4\t\xB4\x04\xB5\t\xB5\x04\xB6\t\xB6\x04\xB7\t\xB7\x04\xB8" + + "\t\xB8\x04\xB9\t\xB9\x04\xBA\t\xBA\x04\xBB\t\xBB\x04\xBC\t\xBC\x04\xBD" + + "\t\xBD\x04\xBE\t\xBE\x04\xBF\t\xBF\x04\xC0\t\xC0\x04\xC1\t\xC1\x04\xC2" + + "\t\xC2\x04\xC3\t\xC3\x04\xC4\t\xC4\x04\xC5\t\xC5\x04\xC6\t\xC6\x04\xC7" + + "\t\xC7\x04\xC8\t\xC8\x04\xC9\t\xC9\x04\xCA\t\xCA\x04\xCB\t\xCB\x04\xCC" + + "\t\xCC\x04\xCD\t\xCD\x04\xCE\t\xCE\x04\xCF\t\xCF\x04\xD0\t\xD0\x04\xD1" + + "\t\xD1\x04\xD2\t\xD2\x04\xD3\t\xD3\x04\xD4\t\xD4\x04\xD5\t\xD5\x04\xD6" + + "\t\xD6\x04\xD7\t\xD7\x04\xD8\t\xD8\x04\xD9\t\xD9\x04\xDA\t\xDA\x04\xDB" + + "\t\xDB\x04\xDC\t\xDC\x04\xDD\t\xDD\x04\xDE\t\xDE\x04\xDF\t\xDF\x04\xE0" + + "\t\xE0\x04\xE1\t\xE1\x04\xE2\t\xE2\x04\xE3\t\xE3\x04\xE4\t\xE4\x04\xE5" + + "\t\xE5\x04\xE6\t\xE6\x04\xE7\t\xE7\x04\xE8\t\xE8\x04\xE9\t\xE9\x04\xEA" + + "\t\xEA\x04\xEB\t\xEB\x04\xEC\t\xEC\x04\xED\t\xED\x04\xEE\t\xEE\x04\xEF" + + "\t\xEF\x04\xF0\t\xF0\x04\xF1\t\xF1\x04\xF2\t\xF2\x04\xF3\t\xF3\x04\xF4" + + "\t\xF4\x04\xF5\t\xF5\x04\xF6\t\xF6\x04\xF7\t\xF7\x04\xF8\t\xF8\x04\xF9" + + "\t\xF9\x04\xFA\t\xFA\x04\xFB\t\xFB\x04\xFC\t\xFC\x04\xFD\t\xFD\x04\xFE" + + "\t\xFE\x04\xFF\t\xFF\x04\u0100\t\u0100\x04\u0101\t\u0101\x04\u0102\t\u0102" + + "\x04\u0103\t\u0103\x04\u0104\t\u0104\x04\u0105\t\u0105\x04\u0106\t\u0106" + + "\x04\u0107\t\u0107\x04\u0108\t\u0108\x04\u0109\t\u0109\x04\u010A\t\u010A" + + "\x04\u010B\t\u010B\x04\u010C\t\u010C\x04\u010D\t\u010D\x04\u010E\t\u010E" + + "\x04\u010F\t\u010F\x04\u0110\t\u0110\x04\u0111\t\u0111\x04\u0112\t\u0112" + + "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x03\x03\x03\x03\x03\x03\x03\x03\x04" + + "\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x05" + + "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x06\x03\x06\x03\x06\x03\x06" + + "\x03\x07\x03\x07\x03\x07\x03\x07\x03\b\x03\b\x03\b\x03\b\x03\b\x03\t\x03" + + "\t\x03\t\x03\t\x03\t\x03\t\x03\n\x03\n\x03\n\x03\v\x03\v\x03\v\x03\v\x03" + + "\f\x03\f\x03\f\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03" + + "\r\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03" + + "\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0F\x03\x0F\x03\x0F\x03" + + "\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x10\x03\x10\x03" + + "\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x11\x03\x11\x03\x11\x03" + + "\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x12\x03" + + "\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03" + + "\x12\x03\x12\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13\x03" + + "\x13\x03\x13\x03\x13\x03\x13\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14\x03" + + "\x14\x03\x14\x03\x14\x03\x14\x03\x15\x03\x15\x03\x15\x03\x15\x03\x15\x03" + + "\x15\x03\x15\x03\x15\x03\x16\x03\x16\x03\x16\x03\x16\x03\x16\x03\x17\x03" + + "\x17\x03\x17\x03\x17\x03\x17\x03\x17\x03\x18\x03\x18\x03\x18\x03\x18\x03" + + "\x18\x03\x18\x03\x18\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19\x03" + + "\x19\x03\x19\x03\x19\x03\x1A\x03\x1A\x03\x1A\x03\x1A\x03\x1A\x03\x1A\x03" + + "\x1A\x03\x1A\x03\x1A\x03\x1A\x03\x1A\x03\x1A\x03\x1A\x03\x1A\x03\x1B\x03" + + "\x1B\x03\x1B\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03" + + "\x1C\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1E\x03\x1E\x03\x1E\x03" + + "\x1E\x03\x1E\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x03" + + " \x03 \x03 \x03 \x03 \x03 \x03 \x03!\x03!\x03!\x03!\x03!\x03!\x03!\x03" + + "\"\x03\"\x03\"\x03\"\x03\"\x03\"\x03\"\x03\"\x03#\x03#\x03#\x03#\x03#" + + "\x03#\x03#\x03#\x03$\x03$\x03$\x03$\x03$\x03$\x03$\x03$\x03$\x03$\x03" + + "$\x03$\x03%\x03%\x03%\x03%\x03%\x03%\x03%\x03%\x03&\x03&\x03&\x03&\x03" + + "&\x03&\x03&\x03\'\x03\'\x03\'\x03\'\x03\'\x03\'\x03(\x03(\x03(\x03(\x03" + + "(\x03(\x03(\x03(\x03)\x03)\x03)\x03)\x03)\x03)\x03)\x03)\x03)\x03)\x03" + + ")\x03)\x03)\x03*\x03*\x03*\x03*\x03*\x03*\x03*\x03*\x03*\x03*\x03*\x03" + + "*\x03*\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x03" + + "+\x03,\x03,\x03,\x03,\x03,\x03,\x03,\x03,\x03,\x03,\x03,\x03,\x03,\x03" + + ",\x03,\x03,\x03,\x03,\x03-\x03-\x03-\x03-\x03-\x03-\x03-\x03-\x03-\x03" + + "-\x03-\x03-\x03-\x03.\x03.\x03.\x03.\x03.\x03/\x03/\x03/\x03/\x03/\x03" + + "/\x03/\x03/\x03/\x030\x030\x030\x030\x030\x030\x030\x030\x030\x030\x03" + + "1\x031\x031\x031\x032\x032\x032\x032\x032\x033\x033\x033\x033\x033\x03" + + "3\x033\x034\x034\x034\x034\x034\x034\x034\x034\x035\x035\x035\x035\x03" + + "5\x035\x035\x035\x035\x035\x036\x036\x036\x036\x036\x036\x036\x036\x03" + + "7\x037\x037\x037\x037\x037\x037\x038\x038\x038\x038\x038\x039\x039\x03" + + "9\x039\x039\x039\x039\x039\x039\x03:\x03:\x03:\x03:\x03:\x03:\x03:\x03" + + ":\x03:\x03;\x03;\x03;\x03;\x03;\x03<\x03<\x03<\x03<\x03<\x03=\x03=\x03" + + "=\x03=\x03=\x03=\x03=\x03=\x03=\x03>\x03>\x03>\x03>\x03?\x03?\x03?\x03" + + "?\x03?\x03?\x03?\x03@\x03@\x03@\x03@\x03@\x03@\x03@\x03@\x03A\x03A\x03" + + "A\x03A\x03A\x03A\x03A\x03B\x03B\x03B\x03B\x03B\x03B\x03B\x03B\x03B\x03" + + "B\x03C\x03C\x03C\x03C\x03C\x03C\x03C\x03D\x03D\x03D\x03D\x03D\x03D\x03" + + "D\x03D\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03F\x03F\x03F\x03F\x03" + + "F\x03F\x03F\x03F\x03F\x03G\x03G\x03G\x03G\x03G\x03G\x03H\x03H\x03H\x03" + + "H\x03H\x03H\x03H\x03I\x03I\x03I\x03I\x03I\x03I\x03I\x03I\x03I\x03I\x03" + + "I\x03J\x03J\x03J\x03J\x03J\x03J\x03K\x03K\x03K\x03K\x03K\x03K\x03K\x03" + + "L\x03L\x03L\x03L\x03L\x03L\x03M\x03M\x03M\x03M\x03M\x03M\x03M\x03M\x03" + + "M\x03M\x03M\x03M\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03" + + "O\x03O\x03O\x03O\x03P\x03P\x03P\x03P\x03P\x03P\x03P\x03Q\x03Q\x03Q\x03" + + "Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03R\x03R\x03R\x03R\x03R\x03R\x03R\x03" + + "R\x03S\x03S\x03S\x03S\x03S\x03T\x03T\x03T\x03T\x03T\x03U\x03U\x03U\x03" + + "U\x03U\x03U\x03U\x03U\x03U\x03V\x03V\x03V\x03V\x03V\x03V\x03V\x03V\x03" + + "V\x03V\x03W\x03W\x03W\x03W\x03W\x03W\x03X\x03X\x03X\x03X\x03X\x03X\x03" + + "Y\x03Y\x03Y\x03Y\x03Y\x03Y\x03Y\x03Y\x03Y\x03Z\x03Z\x03Z\x03Z\x03Z\x03" + + "[\x03[\x03[\x03[\x03[\x03[\x03[\x03\\\x03\\\x03\\\x03\\\x03\\\x03]\x03" + + "]\x03]\x03]\x03]\x03]\x03^\x03^\x03^\x03_\x03_\x03_\x03`\x03`\x03`\x03" + + "`\x03`\x03`\x03`\x03`\x03`\x03`\x03a\x03a\x03a\x03a\x03a\x03a\x03a\x03" + + "a\x03a\x03a\x03a\x03a\x03b\x03b\x03b\x03b\x03b\x03b\x03c\x03c\x03c\x03" + + "c\x03c\x03c\x03c\x03d\x03d\x03d\x03d\x03d\x03d\x03d\x03e\x03e\x03e\x03" + + "e\x03e\x03e\x03e\x03e\x03e\x03e\x03f\x03f\x03f\x03f\x03f\x03f\x03f\x03" + + "f\x03f\x03g\x03g\x03g\x03g\x03g\x03g\x03g\x03g\x03g\x03g\x03g\x03g\x03" + + "g\x03h\x03h\x03h\x03h\x03h\x03i\x03i\x03i\x03i\x03i\x03i\x03i\x03i\x03" + + "j\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x03k\x03k\x03k\x03" + + "l\x03l\x03l\x03l\x03l\x03m\x03m\x03m\x03m\x03n\x03n\x03n\x03n\x03n\x03" + + "o\x03o\x03o\x03o\x03o\x03p\x03p\x03p\x03p\x03p\x03p\x03p\x03p\x03q\x03" + + "q\x03q\x03q\x03q\x03r\x03r\x03r\x03r\x03r\x03s\x03s\x03s\x03s\x03s\x03" + + "s\x03t\x03t\x03t\x03t\x03t\x03t\x03u\x03u\x03u\x03u\x03u\x03v\x03v\x03" + + "v\x03v\x03v\x03v\x03v\x03v\x03v\x03v\x03w\x03w\x03w\x03w\x03w\x03w\x03" + + "w\x03w\x03w\x03w\x03w\x03w\x03w\x03w\x03w\x03x\x03x\x03x\x03x\x03x\x03" + + "x\x03x\x03x\x03x\x03y\x03y\x03y\x03y\x03z\x03z\x03z\x03z\x03z\x03z\x03" + + "z\x03{\x03{\x03{\x03{\x03{\x03{\x03{\x03{\x03|\x03|\x03|\x03|\x03|\x03" + + "|\x03}\x03}\x03}\x03}\x03}\x03}\x03}\x03~\x03~\x03~\x03~\x03~\x03~\x03" + + "~\x03~\x03~\x03\x7F\x03\x7F\x03\x7F\x03\x7F\x03\x80\x03\x80\x03\x80\x03" + + "\x80\x03\x81\x03\x81\x03\x81\x03\x81\x03\x81\x03\x82\x03\x82\x03\x82\x03" + + "\x82\x03\x82\x03\x83\x03\x83\x03\x83\x03\x83\x03\x83\x03\x83\x03\x83\x03" + + "\x83\x03\x83\x03\x83\x03\x84\x03\x84\x03\x84\x03\x84\x03\x85\x03\x85\x03" + + "\x85\x03\x85\x03\x85\x03\x86\x03\x86\x03\x86\x03\x86\x03\x86\x03\x86\x03" + + "\x87\x03\x87\x03\x87\x03\x87\x03\x87\x03\x87\x03\x87\x03\x88\x03\x88\x03" + + "\x88\x03\x89\x03\x89\x03\x89\x03\x89\x03\x89\x03\x89\x03\x89\x03\x8A\x03" + + "\x8A\x03\x8A\x03\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8C\x03" + + "\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03" + + "\x8C\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8E\x03\x8E\x03" + + "\x8E\x03\x8E\x03\x8E\x03\x8E\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03" + + "\x90\x03\x90\x03\x90\x03\x90\x03\x90\x03\x90\x03\x90\x03\x90\x03\x90\x03" + + "\x90\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03" + + "\x91\x03\x91\x03\x92\x03\x92\x03\x92\x03\x92\x03\x92\x03\x92\x03\x92\x03" + + "\x92\x03\x92\x03\x92\x03\x92\x03\x93\x03\x93\x03\x93\x03\x93\x03\x93\x03" + + "\x93\x03\x93\x03\x93\x03\x94\x03\x94\x03\x94\x03\x94\x03\x94\x03\x94\x03" + + "\x94\x03\x94\x03\x94\x03\x95\x03\x95\x03\x95\x03\x95\x03\x95\x03\x95\x03" + + "\x95\x03\x95\x03\x95\x03\x95\x03\x96\x03\x96\x03\x96\x03\x96\x03\x96\x03" + + "\x96\x03\x96\x03\x96\x03\x97\x03\x97\x03\x97\x03\x97\x03\x97\x03\x97\x03" + + "\x97\x03\x97\x03\x97\x03\x97\x03\x97\x03\x97\x03\x98\x03\x98\x03\x98\x03" + + "\x98\x03\x98\x03\x98\x03\x98\x03\x98\x03\x98\x03\x98\x03\x98\x03\x99\x03" + + "\x99\x03\x99\x03\x99\x03\x99\x03\x99\x03\x99\x03\x99\x03\x99\x03\x99\x03" + + "\x99\x03\x9A\x03\x9A\x03\x9A\x03\x9A\x03\x9A\x03\x9A\x03\x9B\x03\x9B\x03" + + "\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9C\x03\x9C\x03\x9C\x03" + + "\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03" + + "\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9E\x03\x9E\x03\x9E\x03" + + "\x9E\x03\x9E\x03\x9E\x03\x9E\x03\x9E\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03" + + "\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03" + + "\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA1\x03\xA1\x03\xA1\x03\xA1\x03\xA1\x03" + + "\xA1\x03\xA1\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03" + + "\xA2\x03\xA3\x03\xA3\x03\xA3\x03\xA3\x03\xA3\x03\xA3\x03\xA3\x03\xA4\x03" + + "\xA4\x03\xA4\x03\xA4\x03\xA4\x03\xA4\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03" + + "\xA5\x03\xA5\x03\xA6\x03\xA6\x03\xA6\x03\xA6\x03\xA6\x03\xA7\x03\xA7\x03" + + "\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA9\x03" + + "\xA9\x03\xA9\x03\xA9\x03\xA9\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03" + + "\xAA\x03\xAA\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03" + + "\xAB\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAD\x03" + + "\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAE\x03\xAE\x03" + + "\xAE\x03\xAE\x03\xAE\x03\xAE\x03\xAE\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03" + + "\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03" + + "\xAF\x03\xAF\x03\xAF\x03\xB0\x03\xB0\x03\xB0\x03\xB0\x03\xB1\x03\xB1\x03" + + "\xB1\x03\xB1\x03\xB1\x03\xB2\x03\xB2\x03\xB2\x03\xB2\x03\xB2\x03\xB2\x03" + + "\xB2\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x03\xB4\x03\xB4\x03\xB4\x03" + + "\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB5\x03\xB5\x03\xB5\x03" + + "\xB5\x03\xB5\x03\xB6\x03\xB6\x03\xB6\x03\xB6\x03\xB6\x03\xB6\x03\xB7\x03" + + "\xB7\x03\xB7\x03\xB7\x03\xB7\x03\xB7\x03\xB7\x03\xB8\x03\xB8\x03\xB8\x03" + + "\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03" + + "\xB8\x03\xB8\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x03" + + "\xB9\x03\xB9\x03\xB9\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03" + + "\xBA\x03\xBB\x03\xBB\x03\xBB\x03\xBB\x03\xBB\x03\xBB\x03\xBB\x03\xBC\x03" + + "\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03" + + "\xBC\x03\xBC\x03\xBC\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x03" + + "\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBF\x03\xBF\x03" + + "\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03" + + "\xBF\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03" + + "\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03" + + "\xC2\x03\xC2\x03\xC2\x03\xC3\x03\xC3\x03\xC3\x03\xC3\x03\xC3\x03\xC4\x03" + + "\xC4\x03\xC4\x03\xC4\x03\xC4\x03\xC4\x03\xC4\x03\xC4\x03\xC4\x03\xC5\x03" + + "\xC5\x03\xC5\x03\xC5\x03\xC5\x03\xC5\x03\xC5\x03\xC5\x03\xC5\x03\xC6\x03" + + "\xC6\x03\xC6\x03\xC6\x03\xC6\x03\xC6\x03\xC6\x03\xC6\x03\xC6\x03\xC7\x03" + + "\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC8\x03\xC8\x03" + + "\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC9\x03" + + "\xC9\x03\xC9\x03\xC9\x03\xC9\x03\xC9\x03\xCA\x03\xCA\x03\xCA\x03\xCA\x03" + + "\xCA\x03\xCA\x03\xCA\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03" + + "\xCC\x03\xCC\x03\xCC\x03\xCC\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03" + + "\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCF\x03\xCF\x03\xCF\x03" + + "\xCF\x03\xCF\x03\xCF\x03\xCF\x03\xCF\x03\xCF\x03\xCF\x03\xD0\x03\xD0\x03" + + "\xD0\x03\xD0\x03\xD0\x03\xD0\x03\xD0\x03\xD1\x03\xD1\x03\xD1\x03\xD1\x03" + + "\xD2\x03\xD2\x03\xD2\x03\xD2\x03\xD2\x03\xD2\x03\xD3\x03\xD3\x03\xD3\x03" + + "\xD3\x03\xD3\x03\xD3\x03\xD3\x03\xD4\x03\xD4\x03\xD4\x03\xD4\x03\xD4\x03" + + "\xD5\x03\xD5\x03\xD5\x03\xD5\x03\xD5\x03\xD5\x03\xD6\x03\xD6\x03\xD6\x03" + + "\xD6\x03\xD6\x03\xD7\x03\xD7\x03\xD7\x03\xD7\x03\xD7\x03\xD7\x03\xD8\x03" + + "\xD8\x03\xD8\x03\xD8\x03\xD8\x03\xD9\x03\xD9\x03\xD9\x03\xD9\x03\xD9\x03" + + "\xDA\x03\xDA\x03\xDA\x03\xDA\x03\xDA\x03\xDA\x03\xDB\x03\xDB\x03\xDB\x03" + + "\xDB\x03\xDB\x03\xDB\x03\xDB\x03\xDB\x03\xDB\x03\xDC\x03\xDC\x03\xDC\x03" + + "\xDC\x03\xDD\x03\xDD\x03\xDD\x03\xDD\x03\xDD\x03\xDE\x03\xDE\x03\xDE\x03" + + "\xDE\x03\xDE\x03\xDE\x03\xDE\x03\xDE\x03\xDE\x03\xDE\x03\xDE\x03\xDE\x03" + + "\xDE\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xE0\x03" + + "\xE0\x03\xE0\x03\xE0\x03\xE0\x03\xE0\x03\xE0\x03\xE0\x03\xE0\x03\xE0\x03" + + "\xE0\x03\xE1\x03\xE1\x03\xE1\x03\xE1\x03\xE1\x03\xE1\x03\xE1\x03\xE1\x03" + + "\xE1\x03\xE1\x03\xE1\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03\xE3\x03" + + "\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE4\x03" + + "\xE4\x03\xE4\x03\xE4\x03\xE4\x03\xE4\x03\xE4\x03\xE4\x03\xE4\x03\xE4\x03" + + "\xE4\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03" + + "\xE5\x03\xE5\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03" + + "\xE6\x03\xE6\x03\xE6\x03\xE7\x03\xE7\x03\xE8\x03\xE8\x03\xE8\x03\xE8\x05" + + "\xE8\u08D7\n\xE8\x03\xE9\x03\xE9\x03\xEA\x03\xEA\x03\xEA\x03\xEB\x03\xEB" + + "\x03\xEC\x03\xEC\x03\xEC\x03\xED\x03\xED\x03\xEE\x03\xEE\x03\xEF\x03\xEF" + + "\x03\xF0\x03\xF0\x03\xF1\x03\xF1\x03\xF2\x03\xF2\x03\xF2\x03\xF3\x03\xF3" + + "\x03\xF4\x03\xF4\x03\xF5\x03\xF5\x03\xF6\x03\xF6\x03\xF7\x03\xF7\x03\xF8" + + "\x03\xF8\x03\xF9\x03\xF9\x03\xFA\x03\xFA\x03\xFB\x03\xFB\x03\xFC\x03\xFC" + + "\x03\xFD\x03\xFD\x03\xFE\x03\xFE\x03\xFF\x03\xFF\x03\xFF\x03\u0100\x03" + + "\u0100\x03\u0100\x03\u0100\x07\u0100\u090F\n\u0100\f\u0100\x0E\u0100\u0912" + + "\v\u0100\x03\u0100\x03\u0100\x03\u0100\x03\u0100\x03\u0100\x07\u0100\u0919" + + "\n\u0100\f\u0100\x0E\u0100\u091C\v\u0100\x03\u0100\x05\u0100\u091F\n\u0100" + + "\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101" + + "\x07\u0101\u0928\n\u0101\f\u0101\x0E\u0101\u092B\v\u0101\x03\u0101\x03" + + "\u0101\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x07\u0102\u0933\n\u0102" + + "\f\u0102\x0E\u0102\u0936\v\u0102\x03\u0102\x03\u0102\x03\u0103\x06\u0103" + + "\u093B\n\u0103\r\u0103\x0E\u0103\u093C\x03\u0104\x06\u0104\u0940\n\u0104" + + "\r\u0104\x0E\u0104\u0941\x03\u0104\x03\u0104\x07\u0104\u0946\n\u0104\f" + + "\u0104\x0E\u0104\u0949\v\u0104\x03\u0104\x03\u0104\x06\u0104\u094D\n\u0104" + + "\r\u0104\x0E\u0104\u094E\x05\u0104\u0951\n\u0104\x03\u0105\x06\u0105\u0954" + + "\n\u0105\r\u0105\x0E\u0105\u0955\x03\u0105\x03\u0105\x07\u0105\u095A\n" + + "\u0105\f\u0105\x0E\u0105\u095D\v\u0105\x05\u0105\u095F\n\u0105\x03\u0105" + + "\x03\u0105\x03\u0105\x03\u0105\x06\u0105\u0965\n\u0105\r\u0105\x0E\u0105" + + "\u0966\x03\u0105\x03\u0105\x05\u0105\u096B\n\u0105\x03\u0106\x03\u0106" + + "\x05\u0106\u096F\n\u0106\x03\u0106\x03\u0106\x03\u0106\x07\u0106\u0974" + + "\n\u0106\f\u0106\x0E\u0106\u0977\v\u0106\x03\u0107\x03\u0107\x03\u0107" + + "\x03\u0107\x06\u0107\u097D\n\u0107\r\u0107\x0E\u0107\u097E\x03\u0108\x03" + + "\u0108\x03\u0108\x03\u0108\x07\u0108\u0985\n\u0108\f\u0108\x0E\u0108\u0988" + + "\v\u0108\x03\u0108\x03\u0108\x03\u0109\x03\u0109\x03\u0109\x03\u0109\x07" + + "\u0109\u0990\n\u0109\f\u0109\x0E\u0109\u0993\v\u0109\x03\u0109\x03\u0109" + + "\x03\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010A" + + "\x03\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010A" + + "\x03\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010A" + + "\x03\u010A\x03\u010A\x03\u010B"; + private static readonly _serializedATNSegment1: string = + "\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B" + + "\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B" + + "\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B" + + "\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010C" + + "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + + "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + + "\x03\u010C\x03\u010C\x03\u010C\x03\u010D\x03\u010D\x05\u010D\u09DE\n\u010D" + + "\x03\u010D\x06\u010D\u09E1\n\u010D\r\u010D\x0E\u010D\u09E2\x03\u010E\x03" + + "\u010E\x03\u010F\x03\u010F\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x07" + + "\u0110\u09ED\n\u0110\f\u0110\x0E\u0110\u09F0\v\u0110\x03\u0110\x05\u0110" + + "\u09F3\n\u0110\x03\u0110\x05\u0110\u09F6\n\u0110\x03\u0110\x03\u0110\x03" + + "\u0111\x03\u0111\x03\u0111\x03\u0111\x07\u0111\u09FE\n\u0111\f\u0111\x0E" + + "\u0111\u0A01\v\u0111\x03\u0111\x03\u0111\x03\u0111\x03\u0111\x03\u0111" + + "\x03\u0112\x06\u0112\u0A09\n\u0112\r\u0112\x0E\u0112\u0A0A\x03\u0112\x03" + + "\u0112\x03\u09FF\x02\x02\u0113\x03\x02\x03\x05\x02\x04\x07\x02\x05\t\x02" + + "\x06\v\x02\x07\r\x02\b\x0F\x02\t\x11\x02\n\x13\x02\v\x15\x02\f\x17\x02" + + "\r\x19\x02\x0E\x1B\x02\x0F\x1D\x02\x10\x1F\x02\x11!\x02\x12#\x02\x13%" + + "\x02\x14\'\x02\x15)\x02\x16+\x02\x17-\x02\x18/\x02\x191\x02\x1A3\x02\x1B" + + "5\x02\x1C7\x02\x1D9\x02\x1E;\x02\x1F=\x02 ?\x02!A\x02\"C\x02#E\x02$G\x02" + + "%I\x02&K\x02\'M\x02(O\x02)Q\x02*S\x02+U\x02,W\x02-Y\x02.[\x02/]\x020_" + + "\x021a\x022c\x023e\x024g\x025i\x026k\x027m\x028o\x029q\x02:s\x02;u\x02" + + "{\x02?}\x02@\x7F\x02A\x81\x02B\x83\x02C\x85\x02D\x87\x02" + + "E\x89\x02F\x8B\x02G\x8D\x02H\x8F\x02I\x91\x02J\x93\x02K\x95\x02L\x97\x02" + + "M\x99\x02N\x9B\x02O\x9D\x02P\x9F\x02Q\xA1\x02R\xA3\x02S\xA5\x02T\xA7\x02" + + "U\xA9\x02V\xAB\x02W\xAD\x02X\xAF\x02Y\xB1\x02Z\xB3\x02[\xB5\x02\\\xB7" + + "\x02]\xB9\x02^\xBB\x02_\xBD\x02`\xBF\x02a\xC1\x02b\xC3\x02c\xC5\x02d\xC7" + + "\x02e\xC9\x02f\xCB\x02g\xCD\x02h\xCF\x02i\xD1\x02j\xD3\x02k\xD5\x02l\xD7" + + "\x02m\xD9\x02n\xDB\x02o\xDD\x02p\xDF\x02q\xE1\x02r\xE3\x02s\xE5\x02t\xE7" + + "\x02u\xE9\x02v\xEB\x02w\xED\x02x\xEF\x02y\xF1\x02z\xF3\x02{\xF5\x02|\xF7" + + "\x02}\xF9\x02~\xFB\x02\x7F\xFD\x02\x80\xFF\x02\x81\u0101\x02\x82\u0103" + + "\x02\x83\u0105\x02\x84\u0107\x02\x85\u0109\x02\x86\u010B\x02\x87\u010D" + + "\x02\x88\u010F\x02\x89\u0111\x02\x8A\u0113\x02\x8B\u0115\x02\x8C\u0117" + + "\x02\x8D\u0119\x02\x8E\u011B\x02\x8F\u011D\x02\x90\u011F\x02\x91\u0121" + + "\x02\x92\u0123\x02\x93\u0125\x02\x94\u0127\x02\x95\u0129\x02\x96\u012B" + + "\x02\x97\u012D\x02\x98\u012F\x02\x99\u0131\x02\x9A\u0133\x02\x9B\u0135" + + "\x02\x9C\u0137\x02\x9D\u0139\x02\x9E\u013B\x02\x9F\u013D\x02\xA0\u013F" + + "\x02\xA1\u0141\x02\xA2\u0143\x02\xA3\u0145\x02\xA4\u0147\x02\xA5\u0149" + + "\x02\xA6\u014B\x02\xA7\u014D\x02\xA8\u014F\x02\xA9\u0151\x02\xAA\u0153" + + "\x02\xAB\u0155\x02\xAC\u0157\x02\xAD\u0159\x02\xAE\u015B\x02\xAF\u015D" + + "\x02\xB0\u015F\x02\xB1\u0161\x02\xB2\u0163\x02\xB3\u0165\x02\xB4\u0167" + + "\x02\xB5\u0169\x02\xB6\u016B\x02\xB7\u016D\x02\xB8\u016F\x02\xB9\u0171" + + "\x02\xBA\u0173\x02\xBB\u0175\x02\xBC\u0177\x02\xBD\u0179\x02\xBE\u017B" + + "\x02\xBF\u017D\x02\xC0\u017F\x02\xC1\u0181\x02\xC2\u0183\x02\xC3\u0185" + + "\x02\xC4\u0187\x02\xC5\u0189\x02\xC6\u018B\x02\xC7\u018D\x02\xC8\u018F" + + "\x02\xC9\u0191\x02\xCA\u0193\x02\xCB\u0195\x02\xCC\u0197\x02\xCD\u0199" + + "\x02\xCE\u019B\x02\xCF\u019D\x02\xD0\u019F\x02\xD1\u01A1\x02\xD2\u01A3" + + "\x02\xD3\u01A5\x02\xD4\u01A7\x02\xD5\u01A9\x02\xD6\u01AB\x02\xD7\u01AD" + + "\x02\xD8\u01AF\x02\xD9\u01B1\x02\xDA\u01B3\x02\xDB\u01B5\x02\xDC\u01B7" + + "\x02\xDD\u01B9\x02\xDE\u01BB\x02\xDF\u01BD\x02\xE0\u01BF\x02\xE1\u01C1" + + "\x02\xE2\u01C3\x02\xE3\u01C5\x02\xE4\u01C7\x02\xE5\u01C9\x02\xE6\u01CB" + + "\x02\xE7\u01CD\x02\xE8\u01CF\x02\xE9\u01D1\x02\xEA\u01D3\x02\xEB\u01D5" + + "\x02\xEC\u01D7\x02\xED\u01D9\x02\xEE\u01DB\x02\xEF\u01DD\x02\xF0\u01DF" + + "\x02\xF1\u01E1\x02\xF2\u01E3\x02\xF3\u01E5\x02\xF4\u01E7\x02\xF5\u01E9" + + "\x02\xF6\u01EB\x02\xF7\u01ED\x02\xF8\u01EF\x02\xF9\u01F1\x02\xFA\u01F3" + + "\x02\xFB\u01F5\x02\xFC\u01F7\x02\xFD\u01F9\x02\xFE\u01FB\x02\xFF\u01FD" + + "\x02\u0100\u01FF\x02\u0101\u0201\x02\u0102\u0203\x02\u0103\u0205\x02\u0104" + + "\u0207\x02\u0105\u0209\x02\u0106\u020B\x02\u0107\u020D\x02\u0108\u020F" + + "\x02\u0109\u0211\x02\u010A\u0213\x02\u010B\u0215\x02\u010C\u0217\x02\u010D" + + "\u0219\x02\x02\u021B\x02\x02\u021D\x02\x02\u021F\x02\u010E\u0221\x02\u010F" + + "\u0223\x02\u0110\x03\x02\v\x03\x02))\x03\x02$$\x05\x02<\x03\x02\x02\x02\u02FB\u02FC\x07E\x02\x02\u02FC" + + "\u02FD\x07J\x02\x02\u02FD\u02FE\x07C\x02\x02\u02FE\u02FF\x07P\x02\x02" + + "\u02FF\u0300\x07I\x02\x02\u0300\u0301\x07G\x02\x02\u0301@\x03\x02\x02" + + "\x02\u0302\u0303\x07E\x02\x02\u0303\u0304\x07Q\x02\x02\u0304\u0305\x07" + + "N\x02\x02\u0305\u0306\x07W\x02\x02\u0306\u0307\x07O\x02\x02\u0307\u0308" + + "\x07P\x02\x02\u0308B\x03\x02\x02\x02\u0309\u030A\x07E\x02\x02\u030A\u030B" + + "\x07Q\x02\x02\u030B\u030C\x07N\x02\x02\u030C\u030D\x07W\x02\x02\u030D" + + "\u030E\x07O\x02\x02\u030E\u030F\x07P\x02\x02\u030F\u0310\x07U\x02\x02" + + "\u0310D\x03\x02\x02\x02\u0311\u0312\x07E\x02\x02\u0312\u0313\x07Q\x02" + + "\x02\u0313\u0314\x07O\x02\x02\u0314\u0315\x07O\x02\x02\u0315\u0316\x07" + + "G\x02\x02\u0316\u0317\x07P\x02\x02\u0317\u0318\x07V\x02\x02\u0318F\x03" + + "\x02\x02\x02\u0319\u031A\x07E\x02\x02\u031A\u031B\x07Q\x02\x02\u031B\u031C" + + "\x07O\x02\x02\u031C\u031D\x07R\x02\x02\u031D\u031E\x07T\x02\x02\u031E" + + "\u031F\x07G\x02\x02\u031F\u0320\x07U\x02\x02\u0320\u0321\x07U\x02\x02" + + "\u0321\u0322\x07K\x02\x02\u0322\u0323\x07Q\x02\x02\u0323\u0324\x07P\x02" + + "\x02\u0324H\x03\x02\x02\x02\u0325\u0326\x07E\x02\x02\u0326\u0327\x07Q" + + "\x02\x02\u0327\u0328\x07O\x02\x02\u0328\u0329\x07R\x02\x02\u0329\u032A" + + "\x07W\x02\x02\u032A\u032B\x07V\x02\x02\u032B\u032C\x07G\x02\x02\u032C" + + "J\x03\x02\x02\x02\u032D\u032E\x07E\x02\x02\u032E\u032F\x07T\x02\x02\u032F" + + "\u0330\x07G\x02\x02\u0330\u0331\x07C\x02\x02\u0331\u0332\x07V\x02\x02" + + "\u0332\u0333\x07G\x02\x02\u0333L\x03\x02\x02\x02\u0334\u0335\x07E\x02" + + "\x02\u0335\u0336\x07T\x02\x02\u0336\u0337\x07Q\x02\x02\u0337\u0338\x07" + + "U\x02\x02\u0338\u0339\x07U\x02\x02\u0339N\x03\x02\x02\x02\u033A\u033B" + + "\x07E\x02\x02\u033B\u033C\x07W\x02\x02\u033C\u033D\x07T\x02\x02\u033D" + + "\u033E\x07T\x02\x02\u033E\u033F\x07G\x02\x02\u033F\u0340\x07P\x02\x02" + + "\u0340\u0341\x07V\x02\x02\u0341P\x03\x02\x02\x02\u0342\u0343\x07E\x02" + + "\x02\u0343\u0344\x07W\x02\x02\u0344\u0345\x07T\x02\x02\u0345\u0346\x07" + + "T\x02\x02\u0346\u0347\x07G\x02\x02\u0347\u0348\x07P\x02\x02\u0348\u0349" + + "\x07V\x02\x02\u0349\u034A\x07a\x02\x02\u034A\u034B\x07F\x02\x02\u034B" + + "\u034C\x07C\x02\x02\u034C\u034D\x07V\x02\x02\u034D\u034E\x07G\x02\x02" + + "\u034ER\x03\x02\x02\x02\u034F\u0350\x07E\x02\x02\u0350\u0351\x07W\x02" + + "\x02\u0351\u0352\x07T\x02\x02\u0352\u0353\x07T\x02\x02\u0353\u0354\x07" + + "G\x02\x02\u0354\u0355\x07P\x02\x02\u0355\u0356\x07V\x02\x02\u0356\u0357" + + "\x07a\x02\x02\u0357\u0358\x07R\x02\x02\u0358\u0359\x07C\x02\x02\u0359" + + "\u035A\x07V\x02\x02\u035A\u035B\x07J\x02\x02\u035BT\x03\x02\x02\x02\u035C" + + "\u035D\x07E\x02\x02\u035D\u035E\x07W\x02\x02\u035E\u035F\x07T\x02\x02" + + "\u035F\u0360\x07T\x02\x02\u0360\u0361\x07G\x02\x02\u0361\u0362\x07P\x02" + + "\x02\u0362\u0363\x07V\x02\x02\u0363\u0364\x07a\x02\x02\u0364\u0365\x07" + + "V\x02\x02\u0365\u0366\x07K\x02\x02\u0366\u0367\x07O\x02\x02\u0367\u0368" + + "\x07G\x02\x02\u0368V\x03\x02\x02\x02\u0369\u036A\x07E\x02\x02\u036A\u036B" + + "\x07W\x02\x02\u036B\u036C\x07T\x02\x02\u036C\u036D\x07T\x02\x02\u036D" + + "\u036E\x07G\x02\x02\u036E\u036F\x07P\x02\x02\u036F\u0370\x07V\x02\x02" + + "\u0370\u0371\x07a\x02\x02\u0371\u0372\x07V\x02\x02\u0372\u0373\x07K\x02" + + "\x02\u0373\u0374\x07O\x02\x02\u0374\u0375\x07G\x02\x02\u0375\u0376\x07" + + "U\x02\x02\u0376\u0377\x07V\x02\x02\u0377\u0378\x07C\x02\x02\u0378\u0379" + + "\x07O\x02\x02\u0379\u037A\x07R\x02\x02\u037AX\x03\x02\x02\x02\u037B\u037C" + + "\x07E\x02\x02\u037C\u037D\x07W\x02\x02\u037D\u037E\x07T\x02\x02\u037E" + + "\u037F\x07T\x02\x02\u037F\u0380\x07G\x02\x02\u0380\u0381\x07P\x02\x02" + + "\u0381\u0382\x07V\x02\x02\u0382\u0383\x07a\x02\x02\u0383\u0384\x07W\x02" + + "\x02\u0384\u0385\x07U\x02\x02\u0385\u0386\x07G\x02\x02\u0386\u0387\x07" + + "T\x02\x02\u0387Z\x03\x02\x02\x02\u0388\u0389\x07F\x02\x02\u0389\u038A" + + "\x07C\x02\x02\u038A\u038B\x07V\x02\x02\u038B\u038C\x07C\x02\x02\u038C" + + "\\\x03\x02\x02\x02\u038D\u038E\x07F\x02\x02\u038E\u038F\x07C\x02\x02\u038F" + + "\u0390\x07V\x02\x02\u0390\u0391\x07C\x02\x02\u0391\u0392\x07D\x02\x02" + + "\u0392\u0393\x07C\x02\x02\u0393\u0394\x07U\x02\x02\u0394\u0395\x07G\x02" + + "\x02\u0395^\x03\x02\x02\x02\u0396\u0397\x07F\x02\x02\u0397\u0398\x07C" + + "\x02\x02\u0398\u0399\x07V\x02\x02\u0399\u039A\x07C\x02\x02\u039A\u039B" + + "\x07D\x02\x02\u039B\u039C\x07C\x02\x02\u039C\u039D\x07U\x02\x02\u039D" + + "\u039E\x07G\x02\x02\u039E\u039F\x07U\x02\x02\u039F`\x03\x02\x02\x02\u03A0" + + "\u03A1\x07F\x02\x02\u03A1\u03A2\x07C\x02\x02\u03A2\u03A3\x07[\x02\x02" + + "\u03A3b\x03\x02\x02\x02\u03A4\u03A5\x07F\x02\x02\u03A5\u03A6\x07C\x02" + + "\x02\u03A6\u03A7\x07[\x02\x02\u03A7\u03A8\x07U\x02\x02\u03A8d\x03\x02" + + "\x02\x02\u03A9\u03AA\x07F\x02\x02\u03AA\u03AB\x07G\x02\x02\u03AB\u03AC" + + "\x07N\x02\x02\u03AC\u03AD\x07G\x02\x02\u03AD\u03AE\x07V\x02\x02\u03AE" + + "\u03AF\x07G\x02\x02\u03AFf\x03\x02\x02\x02\u03B0\u03B1\x07F\x02\x02\u03B1" + + "\u03B2\x07G\x02\x02\u03B2\u03B3\x07H\x02\x02\u03B3\u03B4\x07C\x02\x02" + + "\u03B4\u03B5\x07W\x02\x02\u03B5\u03B6\x07N\x02\x02\u03B6\u03B7\x07V\x02" + + "\x02\u03B7h\x03\x02\x02\x02\u03B8\u03B9\x07F\x02\x02\u03B9\u03BA\x07G" + + "\x02\x02\u03BA\u03BB\x07N\x02\x02\u03BB\u03BC\x07K\x02\x02\u03BC\u03BD" + + "\x07O\x02\x02\u03BD\u03BE\x07K\x02\x02\u03BE\u03BF\x07V\x02\x02\u03BF" + + "\u03C0\x07G\x02\x02\u03C0\u03C1\x07F\x02\x02\u03C1j\x03\x02\x02\x02\u03C2" + + "\u03C3\x07F\x02\x02\u03C3\u03C4\x07K\x02\x02\u03C4\u03C5\x07U\x02\x02" + + "\u03C5\u03C6\x07C\x02\x02\u03C6\u03C7\x07D\x02\x02\u03C7\u03C8\x07N\x02" + + "\x02\u03C8\u03C9\x07G\x02\x02\u03C9l\x03\x02\x02\x02\u03CA\u03CB\x07W" + + "\x02\x02\u03CB\u03CC\x07R\x02\x02\u03CC\u03CD\x07F\x02\x02\u03CD\u03CE" + + "\x07C\x02\x02\u03CE\u03CF\x07V\x02\x02\u03CF\u03D0\x07G\x02\x02\u03D0" + + "n\x03\x02\x02\x02\u03D1\u03D2\x07F\x02\x02\u03D2\u03D3\x07G\x02\x02\u03D3" + + "\u03D4\x07U\x02\x02\u03D4\u03D5\x07E\x02\x02\u03D5p\x03\x02\x02\x02\u03D6" + + "\u03D7\x07F\x02\x02\u03D7\u03D8\x07G\x02\x02\u03D8\u03D9\x07U\x02\x02" + + "\u03D9\u03DA\x07E\x02\x02\u03DA\u03DB\x07T\x02\x02\u03DB\u03DC\x07K\x02" + + "\x02\u03DC\u03DD\x07D\x02\x02\u03DD\u03DE\x07G\x02\x02\u03DEr\x03\x02" + + "\x02\x02\u03DF\u03E0\x07F\x02\x02\u03E0\u03E1\x07K\x02\x02\u03E1\u03E2" + + "\x07U\x02\x02\u03E2\u03E3\x07V\x02\x02\u03E3\u03E4\x07K\x02\x02\u03E4" + + "\u03E5\x07P\x02\x02\u03E5\u03E6\x07E\x02\x02\u03E6\u03E7\x07V\x02\x02" + + "\u03E7t\x03\x02\x02\x02\u03E8\u03E9\x07F\x02\x02\u03E9\u03EA\x07T\x02" + + "\x02\u03EA\u03EB\x07Q\x02\x02\u03EB\u03EC\x07R\x02\x02\u03ECv\x03\x02" + + "\x02\x02\u03ED\u03EE\x07G\x02\x02\u03EE\u03EF\x07N\x02\x02\u03EF\u03F0" + + "\x07U\x02\x02\u03F0\u03F1\x07G\x02\x02\u03F1x\x03\x02\x02\x02\u03F2\u03F3" + + "\x07G\x02\x02\u03F3\u03F4\x07P\x02\x02\u03F4\u03F5\x07E\x02\x02\u03F5" + + "\u03F6\x07Q\x02\x02\u03F6\u03F7\x07F\x02\x02\u03F7\u03F8\x07K\x02\x02" + + "\u03F8\u03F9\x07P\x02\x02\u03F9\u03FA\x07I\x02\x02\u03FAz\x03\x02\x02" + + "\x02\u03FB\u03FC\x07G\x02\x02\u03FC\u03FD\x07P\x02\x02\u03FD\u03FE\x07" + + "F\x02\x02\u03FE|\x03\x02\x02\x02\u03FF\u0400\x07G\x02\x02\u0400\u0401" + + "\x07U\x02\x02\u0401\u0402\x07E\x02\x02\u0402\u0403\x07C\x02\x02\u0403" + + "\u0404\x07R\x02\x02\u0404\u0405\x07G\x02\x02\u0405~\x03\x02\x02\x02\u0406" + + "\u0407\x07G\x02\x02\u0407\u0408\x07U\x02\x02\u0408\u0409\x07E\x02\x02" + + "\u0409\u040A\x07C\x02\x02\u040A\u040B\x07R\x02\x02\u040B\u040C\x07G\x02" + + "\x02\u040C\u040D\x07F\x02\x02\u040D\x80\x03\x02\x02\x02\u040E\u040F\x07" + + "G\x02\x02\u040F\u0410\x07Z\x02\x02\u0410\u0411\x07E\x02\x02\u0411\u0412" + + "\x07G\x02\x02\u0412\u0413\x07R\x02\x02\u0413\u0414\x07V\x02\x02\u0414" + + "\x82\x03\x02\x02\x02\u0415\u0416\x07G\x02\x02\u0416\u0417\x07Z\x02\x02" + + "\u0417\u0418\x07E\x02\x02\u0418\u0419\x07N\x02\x02\u0419\u041A\x07W\x02" + + "\x02\u041A\u041B\x07F\x02\x02\u041B\u041C\x07K\x02\x02\u041C\u041D\x07" + + "P\x02\x02\u041D\u041E\x07I\x02\x02\u041E\x84\x03\x02\x02\x02\u041F\u0420" + + "\x07G\x02\x02\u0420\u0421\x07Z\x02\x02\u0421\u0422\x07K\x02\x02\u0422" + + "\u0423\x07U\x02\x02\u0423\u0424\x07V\x02\x02\u0424\u0425\x07U\x02\x02" + + "\u0425\x86\x03\x02\x02\x02\u0426\u0427\x07G\x02\x02\u0427\u0428\x07Z\x02" + + "\x02\u0428\u0429\x07R\x02\x02\u0429\u042A\x07N\x02\x02\u042A\u042B\x07" + + "C\x02\x02\u042B\u042C\x07K\x02\x02\u042C\u042D\x07P\x02\x02\u042D\x88" + + "\x03\x02\x02\x02\u042E\u042F\x07G\x02\x02\u042F\u0430\x07Z\x02\x02\u0430" + + "\u0431\x07V\x02\x02\u0431\u0432\x07T\x02\x02\u0432\u0433\x07C\x02\x02" + + "\u0433\u0434\x07E\x02\x02\u0434\u0435\x07V\x02\x02\u0435\x8A\x03\x02\x02" + + "\x02\u0436\u0437\x07G\x02\x02\u0437\u0438\x07Z\x02\x02\u0438\u0439\x07" + + "V\x02\x02\u0439\u043A\x07G\x02\x02\u043A\u043B\x07P\x02\x02\u043B\u043C" + + "\x07F\x02\x02\u043C\u043D\x07G\x02\x02\u043D\u043E\x07F\x02\x02\u043E" + + "\x8C\x03\x02\x02\x02\u043F\u0440\x07H\x02\x02\u0440\u0441\x07C\x02\x02" + + "\u0441\u0442\x07N\x02\x02\u0442\u0443\x07U\x02\x02\u0443\u0444\x07G\x02" + + "\x02\u0444\x8E\x03\x02\x02\x02\u0445\u0446\x07H\x02\x02\u0446\u0447\x07" + + "K\x02\x02\u0447\u0448\x07G\x02\x02\u0448\u0449\x07N\x02\x02\u0449\u044A" + + "\x07F\x02\x02\u044A\u044B\x07U\x02\x02\u044B\x90\x03\x02\x02\x02\u044C" + + "\u044D\x07H\x02\x02\u044D\u044E\x07K\x02\x02\u044E\u044F\x07N\x02\x02" + + "\u044F\u0450\x07G\x02\x02\u0450\u0451\x07H\x02\x02\u0451\u0452\x07Q\x02" + + "\x02\u0452\u0453\x07T\x02\x02\u0453\u0454\x07O\x02\x02\u0454\u0455\x07" + + "C\x02\x02\u0455\u0456\x07V\x02\x02\u0456\x92\x03\x02\x02\x02\u0457\u0458" + + "\x07H\x02\x02\u0458\u0459\x07K\x02\x02\u0459\u045A\x07N\x02\x02\u045A" + + "\u045B\x07G\x02\x02\u045B\u045C\x07U\x02\x02\u045C\x94\x03\x02\x02\x02" + + "\u045D\u045E\x07H\x02\x02\u045E\u045F\x07K\x02\x02\u045F\u0460\x07N\x02" + + "\x02\u0460\u0461\x07V\x02\x02\u0461\u0462\x07G\x02\x02\u0462\u0463\x07" + + "T\x02\x02\u0463\x96\x03\x02\x02\x02\u0464\u0465\x07H\x02\x02\u0465\u0466" + + "\x07K\x02\x02\u0466\u0467\x07T\x02\x02\u0467\u0468\x07U\x02\x02\u0468" + + "\u0469\x07V\x02\x02\u0469\x98\x03\x02\x02\x02\u046A\u046B\x07H\x02\x02" + + "\u046B\u046C\x07K\x02\x02\u046C\u046D\x07P\x02\x02\u046D\u046E\x07C\x02" + + "\x02\u046E\u046F\x07N\x02\x02\u046F\u0470\x07K\x02\x02\u0470\u0471\x07" + + "\\\x02\x02\u0471\u0472\x07G\x02\x02\u0472\u0473\x07a\x02\x02\u0473\u0474" + + "\x07H\x02\x02\u0474\u0475\x07P\x02\x02\u0475\x9A\x03\x02\x02\x02\u0476" + + "\u0477\x07H\x02\x02\u0477\u0478\x07Q\x02\x02\u0478\u0479\x07N\x02\x02" + + "\u0479\u047A\x07N\x02\x02\u047A\u047B\x07Q\x02\x02\u047B\u047C\x07Y\x02" + + "\x02\u047C\u047D\x07K\x02\x02\u047D\u047E\x07P\x02\x02\u047E\u047F\x07" + + "I\x02\x02\u047F\x9C\x03\x02\x02\x02\u0480\u0481\x07H\x02\x02\u0481\u0482" + + "\x07Q\x02\x02\u0482\u0483\x07T\x02\x02\u0483\x9E\x03\x02\x02\x02\u0484" + + "\u0485\x07H\x02\x02\u0485\u0486\x07Q\x02\x02\u0486\u0487\x07T\x02\x02" + + "\u0487\u0488\x07O\x02\x02\u0488\u0489\x07C\x02\x02\u0489\u048A\x07V\x02" + + "\x02\u048A\xA0\x03\x02\x02\x02\u048B\u048C\x07H\x02\x02\u048C\u048D\x07" + + "Q\x02\x02\u048D\u048E\x07T\x02\x02\u048E\u048F\x07O\x02\x02\u048F\u0490" + + "\x07C\x02\x02\u0490\u0491\x07V\x02\x02\u0491\u0492\x07V\x02\x02\u0492" + + "\u0493\x07G\x02\x02\u0493\u0494\x07F\x02\x02\u0494\xA2\x03\x02\x02\x02" + + "\u0495\u0496\x07H\x02\x02\u0496\u0497\x07Q\x02\x02\u0497\u0498\x07T\x02" + + "\x02\u0498\u0499\x07G\x02\x02\u0499\u049A\x07K\x02\x02\u049A\u049B\x07" + + "I\x02\x02\u049B\u049C\x07P\x02\x02\u049C\xA4\x03\x02\x02\x02\u049D\u049E" + + "\x07H\x02\x02\u049E\u049F\x07T\x02\x02\u049F\u04A0\x07Q\x02\x02\u04A0" + + "\u04A1\x07O\x02\x02\u04A1\xA6\x03\x02\x02\x02\u04A2\u04A3\x07H\x02\x02" + + "\u04A3\u04A4\x07W\x02\x02\u04A4\u04A5\x07N\x02\x02\u04A5\u04A6\x07N\x02" + + "\x02\u04A6\xA8\x03\x02\x02\x02\u04A7\u04A8\x07H\x02\x02\u04A8\u04A9\x07" + + "W\x02\x02\u04A9\u04AA\x07P\x02\x02\u04AA\u04AB\x07E\x02\x02\u04AB\u04AC" + + "\x07V\x02\x02\u04AC\u04AD\x07K\x02\x02\u04AD\u04AE\x07Q\x02\x02\u04AE" + + "\u04AF\x07P\x02\x02\u04AF\xAA\x03\x02\x02\x02\u04B0\u04B1\x07H\x02\x02" + + "\u04B1\u04B2\x07W\x02\x02\u04B2\u04B3\x07P\x02\x02\u04B3\u04B4\x07E\x02" + + "\x02\u04B4\u04B5\x07V\x02\x02\u04B5\u04B6\x07K\x02\x02\u04B6\u04B7\x07" + + "Q\x02\x02\u04B7\u04B8\x07P\x02\x02\u04B8\u04B9\x07U\x02\x02\u04B9\xAC" + + "\x03\x02\x02\x02\u04BA\u04BB\x07I\x02\x02\u04BB\u04BC\x07T\x02\x02\u04BC" + + "\u04BD\x07C\x02\x02\u04BD\u04BE\x07P\x02\x02\u04BE\u04BF\x07V\x02\x02" + + "\u04BF\xAE\x03\x02\x02\x02\u04C0\u04C1\x07I\x02\x02\u04C1\u04C2\x07T\x02" + + "\x02\u04C2\u04C3\x07Q\x02\x02\u04C3\u04C4\x07W\x02\x02\u04C4\u04C5\x07" + + "R\x02\x02\u04C5\xB0\x03\x02\x02\x02\u04C6\u04C7\x07I\x02\x02\u04C7\u04C8" + + "\x07T\x02\x02\u04C8\u04C9\x07Q\x02\x02\u04C9\u04CA\x07W\x02\x02\u04CA" + + "\u04CB\x07R\x02\x02\u04CB\u04CC\x07K\x02\x02\u04CC\u04CD\x07P\x02\x02" + + "\u04CD\u04CE\x07I\x02\x02\u04CE\xB2\x03\x02\x02\x02\u04CF\u04D0\x07J\x02" + + "\x02\u04D0\u04D1\x07C\x02\x02\u04D1\u04D2\x07U\x02\x02\u04D2\u04D3\x07" + + "J\x02\x02\u04D3\xB4\x03\x02\x02\x02\u04D4\u04D5\x07J\x02\x02\u04D5\u04D6" + + "\x07C\x02\x02\u04D6\u04D7\x07X\x02\x02\u04D7\u04D8\x07K\x02\x02\u04D8" + + "\u04D9\x07P\x02\x02\u04D9\u04DA\x07I\x02\x02\u04DA\xB6\x03\x02\x02\x02" + + "\u04DB\u04DC\x07J\x02\x02\u04DC\u04DD\x07Q\x02\x02\u04DD\u04DE\x07W\x02" + + "\x02\u04DE\u04DF\x07T\x02\x02\u04DF\xB8\x03\x02\x02\x02\u04E0\u04E1\x07" + + "J\x02\x02\u04E1\u04E2\x07Q\x02\x02\u04E2\u04E3\x07W\x02\x02\u04E3\u04E4" + + "\x07T\x02\x02\u04E4\u04E5\x07U\x02\x02\u04E5\xBA\x03\x02\x02\x02\u04E6" + + "\u04E7\x07K\x02\x02\u04E7\u04E8\x07H\x02\x02\u04E8\xBC\x03\x02\x02\x02" + + "\u04E9\u04EA\x07K\x02\x02\u04EA\u04EB\x07P\x02\x02\u04EB\xBE\x03\x02\x02" + + "\x02\u04EC\u04ED\x07K\x02\x02\u04ED\u04EE\x07P\x02\x02\u04EE\u04EF\x07" + + "E\x02\x02\u04EF\u04F0\x07N\x02\x02\u04F0\u04F1\x07W\x02\x02\u04F1\u04F2" + + "\x07F\x02\x02\u04F2\u04F3\x07K\x02\x02\u04F3\u04F4\x07P\x02\x02\u04F4" + + "\u04F5\x07I\x02\x02\u04F5\xC0\x03\x02\x02\x02\u04F6\u04F7\x07K\x02\x02" + + "\u04F7\u04F8\x07P\x02\x02\u04F8\u04F9\x07E\x02\x02\u04F9\u04FA\x07T\x02" + + "\x02\u04FA\u04FB\x07G\x02\x02\u04FB\u04FC\x07O\x02\x02\u04FC\u04FD\x07" + + "G\x02\x02\u04FD\u04FE\x07P\x02\x02\u04FE\u04FF\x07V\x02\x02\u04FF\u0500" + + "\x07C\x02\x02\u0500\u0501\x07N\x02\x02\u0501\xC2\x03\x02\x02\x02\u0502" + + "\u0503\x07K\x02\x02\u0503\u0504\x07P\x02\x02\u0504\u0505\x07P\x02\x02" + + "\u0505\u0506\x07G\x02\x02\u0506\u0507\x07T\x02\x02\u0507\xC4\x03\x02\x02" + + "\x02\u0508\u0509\x07K\x02\x02\u0509\u050A\x07P\x02\x02\u050A\u050B\x07" + + "R\x02\x02\u050B\u050C\x07C\x02\x02\u050C\u050D\x07V\x02\x02\u050D\u050E" + + "\x07J\x02\x02\u050E\xC6\x03\x02\x02\x02\u050F\u0510\x07K\x02\x02\u0510" + + "\u0511\x07P\x02\x02\u0511\u0512\x07U\x02\x02\u0512\u0513\x07G\x02\x02" + + "\u0513\u0514\x07T\x02\x02\u0514\u0515\x07V\x02\x02\u0515\xC8\x03\x02\x02" + + "\x02\u0516\u0517\x07K\x02\x02\u0517\u0518\x07P\x02\x02\u0518\u0519\x07" + + "V\x02\x02\u0519\u051A\x07G\x02\x02\u051A\u051B\x07T\x02\x02\u051B\u051C" + + "\x07U\x02\x02\u051C\u051D\x07G\x02\x02\u051D\u051E\x07E\x02\x02\u051E" + + "\u051F\x07V\x02\x02\u051F\xCA\x03\x02\x02\x02\u0520\u0521\x07K\x02\x02" + + "\u0521\u0522\x07P\x02\x02\u0522\u0523\x07V\x02\x02\u0523\u0524\x07G\x02" + + "\x02\u0524\u0525\x07T\x02\x02\u0525\u0526\x07X\x02\x02\u0526\u0527\x07" + + "C\x02\x02\u0527\u0528\x07N\x02\x02\u0528\xCC\x03\x02\x02\x02\u0529\u052A" + + "\x07K\x02\x02\u052A\u052B\x07P\x02\x02\u052B\u052C\x07V\x02\x02\u052C" + + "\u052D\x07G\x02\x02\u052D\u052E\x07T\x02\x02\u052E\u052F\x07O\x02\x02" + + "\u052F\u0530\x07G\x02\x02\u0530\u0531\x07F\x02\x02\u0531\u0532\x07K\x02" + + "\x02\u0532\u0533\x07C\x02\x02\u0533\u0534\x07V\x02\x02\u0534\u0535\x07" + + "G\x02\x02\u0535\xCE\x03\x02\x02\x02\u0536\u0537\x07K\x02\x02\u0537\u0538" + + "\x07P\x02\x02\u0538\u0539\x07V\x02\x02\u0539\u053A\x07Q\x02\x02\u053A" + + "\xD0\x03\x02\x02\x02\u053B\u053C\x07K\x02\x02\u053C\u053D\x07P\x02\x02" + + "\u053D\u053E\x07K\x02\x02\u053E\u053F\x07V\x02\x02\u053F\u0540\x07a\x02" + + "\x02\u0540\u0541\x07H\x02\x02\u0541\u0542\x07P\x02\x02\u0542\xD2\x03\x02" + + "\x02\x02\u0543\u0544\x07K\x02\x02\u0544\u0545\x07P\x02\x02\u0545\u0546" + + "\x07X\x02\x02\u0546\u0547\x07C\x02\x02\u0547\u0548\x07N\x02\x02\u0548" + + "\u0549\x07K\x02\x02\u0549\u054A\x07F\x02\x02\u054A\u054B\x07C\x02\x02" + + "\u054B\u054C\x07V\x02\x02\u054C\u054D\x07G\x02\x02\u054D\xD4\x03\x02\x02" + + "\x02\u054E\u054F\x07K\x02\x02\u054F\u0550\x07U\x02\x02\u0550\xD6\x03\x02" + + "\x02\x02\u0551\u0552\x07L\x02\x02\u0552\u0553\x07Q\x02\x02\u0553\u0554" + + "\x07K\x02\x02\u0554\u0555\x07P\x02\x02\u0555\xD8\x03\x02\x02\x02\u0556" + + "\u0557\x07M\x02\x02\u0557\u0558\x07G\x02\x02\u0558\u0559\x07[\x02\x02" + + "\u0559\xDA\x03\x02\x02\x02\u055A\u055B\x07M\x02\x02\u055B\u055C\x07W\x02" + + "\x02\u055C\u055D\x07F\x02\x02\u055D\u055E\x07W\x02\x02\u055E\xDC\x03\x02" + + "\x02\x02\u055F\u0560\x07N\x02\x02\u0560\u0561\x07C\x02\x02\u0561\u0562" + + "\x07U\x02\x02\u0562\u0563\x07V\x02\x02\u0563\xDE\x03\x02\x02\x02\u0564" + + "\u0565\x07N\x02\x02\u0565\u0566\x07C\x02\x02\u0566\u0567\x07V\x02\x02" + + "\u0567\u0568\x07G\x02\x02\u0568\u0569\x07T\x02\x02\u0569\u056A\x07C\x02" + + "\x02\u056A\u056B\x07N\x02\x02\u056B\xE0\x03\x02\x02\x02\u056C\u056D\x07" + + "N\x02\x02\u056D\u056E\x07G\x02\x02\u056E\u056F\x07H\x02\x02\u056F\u0570" + + "\x07V\x02\x02\u0570\xE2\x03\x02\x02\x02\u0571\u0572\x07N\x02\x02\u0572" + + "\u0573\x07K\x02\x02\u0573\u0574\x07M\x02\x02\u0574\u0575\x07G\x02\x02" + + "\u0575\xE4\x03\x02\x02\x02\u0576\u0577\x07N\x02\x02\u0577\u0578\x07K\x02" + + "\x02\u0578\u0579\x07O\x02\x02\u0579\u057A\x07K\x02\x02\u057A\u057B\x07" + + "V\x02\x02\u057B\xE6\x03\x02\x02\x02\u057C\u057D\x07N\x02\x02\u057D\u057E" + + "\x07K\x02\x02\u057E\u057F\x07P\x02\x02\u057F\u0580\x07G\x02\x02\u0580" + + "\u0581\x07U\x02\x02\u0581\xE8\x03\x02\x02\x02\u0582\u0583\x07N\x02\x02" + + "\u0583\u0584\x07Q\x02\x02\u0584\u0585\x07C\x02\x02\u0585\u0586\x07F\x02" + + "\x02\u0586\xEA\x03\x02\x02\x02\u0587\u0588\x07N\x02\x02\u0588\u0589\x07" + + "Q\x02\x02\u0589\u058A\x07E\x02\x02\u058A\u058B\x07C\x02\x02\u058B\u058C" + + "\x07N\x02\x02\u058C\u058D\x07V\x02\x02\u058D\u058E\x07K\x02\x02\u058E" + + "\u058F\x07O\x02\x02\u058F\u0590\x07G\x02\x02\u0590\xEC\x03\x02\x02\x02" + + "\u0591\u0592\x07N\x02\x02\u0592\u0593\x07Q\x02\x02\u0593\u0594\x07E\x02" + + "\x02\u0594\u0595\x07C\x02\x02\u0595\u0596\x07N\x02\x02\u0596\u0597\x07" + + "V\x02\x02\u0597\u0598\x07K\x02\x02\u0598\u0599\x07O\x02\x02\u0599\u059A" + + "\x07G\x02\x02\u059A\u059B\x07U\x02\x02\u059B\u059C\x07V\x02\x02\u059C" + + "\u059D\x07C\x02\x02\u059D\u059E\x07O\x02\x02\u059E\u059F\x07R\x02\x02" + + "\u059F\xEE\x03\x02\x02\x02\u05A0\u05A1\x07O\x02\x02\u05A1\u05A2\x07G\x02" + + "\x02\u05A2\u05A3\x07V\x02\x02\u05A3\u05A4\x07C\x02\x02\u05A4\u05A5\x07" + + "F\x02\x02\u05A5\u05A6\x07C\x02\x02\u05A6\u05A7\x07V\x02\x02\u05A7\u05A8" + + "\x07C\x02\x02\u05A8\xF0\x03\x02\x02\x02\u05A9\u05AA\x07O\x02\x02\u05AA" + + "\u05AB\x07C\x02\x02\u05AB\u05AC\x07R\x02\x02\u05AC\xF2\x03\x02\x02\x02" + + "\u05AD\u05AE\x07O\x02\x02\u05AE\u05AF\x07K\x02\x02\u05AF\u05B0\x07P\x02" + + "\x02\u05B0\u05B1\x07W\x02\x02\u05B1\u05B2\x07V\x02\x02\u05B2\u05B3\x07" + + "G\x02\x02\u05B3\xF4\x03\x02\x02\x02\u05B4\u05B5\x07O\x02\x02\u05B5\u05B6" + + "\x07K\x02\x02\u05B6\u05B7\x07P\x02\x02\u05B7\u05B8\x07W\x02\x02\u05B8" + + "\u05B9\x07V\x02\x02\u05B9\u05BA\x07G\x02\x02\u05BA\u05BB\x07U\x02\x02" + + "\u05BB\xF6\x03\x02\x02\x02\u05BC\u05BD\x07O\x02\x02\u05BD\u05BE\x07Q\x02" + + "\x02\u05BE\u05BF\x07P\x02\x02\u05BF\u05C0\x07V\x02\x02\u05C0\u05C1\x07" + + "J\x02\x02\u05C1\xF8\x03\x02\x02\x02\u05C2\u05C3\x07O\x02\x02\u05C3\u05C4" + + "\x07Q\x02\x02\u05C4\u05C5\x07P\x02\x02\u05C5\u05C6\x07V\x02\x02\u05C6" + + "\u05C7\x07J\x02\x02\u05C7\u05C8\x07U\x02\x02\u05C8\xFA\x03\x02\x02\x02" + + "\u05C9\u05CA\x07O\x02\x02\u05CA\u05CB\x07G\x02\x02\u05CB\u05CC\x07T\x02" + + "\x02\u05CC\u05CD\x07I\x02\x02\u05CD\u05CE\x07G\x02\x02\u05CE\u05CF\x07" + + "a\x02\x02\u05CF\u05D0\x07H\x02\x02\u05D0\u05D1\x07P\x02\x02\u05D1\xFC" + + "\x03\x02\x02\x02\u05D2\u05D3\x07P\x02\x02\u05D3\u05D4\x07H\x02\x02\u05D4" + + "\u05D5\x07E"; + private static readonly _serializedATNSegment3: string = + "\x02\x02\u05D5\xFE\x03\x02\x02\x02\u05D6\u05D7\x07P\x02\x02\u05D7\u05D8" + + "\x07H\x02\x02\u05D8\u05D9\x07F\x02\x02\u05D9\u0100\x03\x02\x02\x02\u05DA" + + "\u05DB\x07P\x02\x02\u05DB\u05DC\x07H\x02\x02\u05DC\u05DD\x07M\x02\x02" + + "\u05DD\u05DE\x07E\x02\x02\u05DE\u0102\x03\x02\x02\x02\u05DF\u05E0\x07" + + "P\x02\x02\u05E0\u05E1\x07H\x02\x02\u05E1\u05E2\x07M\x02\x02\u05E2\u05E3" + + "\x07F\x02\x02\u05E3\u0104\x03\x02\x02\x02\u05E4\u05E5\x07P\x02\x02\u05E5" + + "\u05E6\x07Q\x02\x02\u05E6\u05E7\x07T\x02\x02\u05E7\u05E8\x07O\x02\x02" + + "\u05E8\u05E9\x07C\x02\x02\u05E9\u05EA\x07N\x02\x02\u05EA\u05EB\x07K\x02" + + "\x02\u05EB\u05EC\x07\\\x02\x02\u05EC\u05ED\x07G\x02\x02\u05ED\u0106\x03" + + "\x02\x02\x02\u05EE\u05EF\x07P\x02\x02\u05EF\u05F0\x07Q\x02\x02\u05F0\u05F1" + + "\x07V\x02\x02\u05F1\u0108\x03\x02\x02\x02\u05F2\u05F3\x07P\x02\x02\u05F3" + + "\u05F4\x07W\x02\x02\u05F4\u05F5\x07N\x02\x02\u05F5\u05F6\x07N\x02\x02" + + "\u05F6\u010A\x03\x02\x02\x02\u05F7\u05F8\x07P\x02\x02\u05F8\u05F9\x07" + + "W\x02\x02\u05F9\u05FA\x07N\x02\x02\u05FA\u05FB\x07N\x02\x02\u05FB\u05FC" + + "\x07U\x02\x02\u05FC\u010C\x03\x02\x02\x02\u05FD\u05FE\x07Q\x02\x02\u05FE" + + "\u05FF\x07H\x02\x02\u05FF\u0600\x07H\x02\x02\u0600\u0601\x07U\x02\x02" + + "\u0601\u0602\x07G\x02\x02\u0602\u0603\x07V\x02\x02\u0603\u010E\x03\x02" + + "\x02\x02\u0604\u0605\x07Q\x02\x02\u0605\u0606\x07P\x02\x02\u0606\u0110" + + "\x03\x02\x02\x02\u0607\u0608\x07Q\x02\x02\u0608\u0609\x07R\x02\x02\u0609" + + "\u060A\x07V\x02\x02\u060A\u060B\x07K\x02\x02\u060B\u060C\x07Q\x02\x02" + + "\u060C\u060D\x07P\x02\x02\u060D\u0112\x03\x02\x02\x02\u060E\u060F\x07" + + "Q\x02\x02\u060F\u0610\x07T\x02\x02\u0610\u0114\x03\x02\x02\x02\u0611\u0612" + + "\x07Q\x02\x02\u0612\u0613\x07T\x02\x02\u0613\u0614\x07F\x02\x02\u0614" + + "\u0615\x07G\x02\x02\u0615\u0616\x07T\x02\x02\u0616\u0116\x03\x02\x02\x02" + + "\u0617\u0618\x07Q\x02\x02\u0618\u0619\x07T\x02\x02\u0619\u061A\x07F\x02" + + "\x02\u061A\u061B\x07K\x02\x02\u061B\u061C\x07P\x02\x02\u061C\u061D\x07" + + "C\x02\x02\u061D\u061E\x07N\x02\x02\u061E\u061F\x07K\x02\x02\u061F\u0620" + + "\x07V\x02\x02\u0620\u0621\x07[\x02\x02\u0621\u0118\x03\x02\x02\x02\u0622" + + "\u0623\x07Q\x02\x02\u0623\u0624\x07W\x02\x02\u0624\u0625\x07V\x02\x02" + + "\u0625\u0626\x07G\x02\x02\u0626\u0627\x07T\x02\x02\u0627\u011A\x03\x02" + + "\x02\x02\u0628\u0629\x07Q\x02\x02\u0629\u062A\x07Y\x02\x02\u062A\u062B" + + "\x07P\x02\x02\u062B\u062C\x07G\x02\x02\u062C\u062D\x07T\x02\x02\u062D" + + "\u011C\x03\x02\x02\x02\u062E\u062F\x07Q\x02\x02\u062F\u0630\x07X\x02\x02" + + "\u0630\u0631\x07G\x02\x02\u0631\u0632\x07T\x02\x02\u0632\u011E\x03\x02" + + "\x02\x02\u0633\u0634\x07Q\x02\x02\u0634\u0635\x07X\x02\x02\u0635\u0636" + + "\x07G\x02\x02\u0636\u0637\x07T\x02\x02\u0637\u0638\x07Y\x02\x02\u0638" + + "\u0639\x07T\x02\x02\u0639\u063A\x07K\x02\x02\u063A\u063B\x07V\x02\x02" + + "\u063B\u063C\x07G\x02\x02\u063C\u0120\x03\x02\x02\x02\u063D\u063E\x07" + + "R\x02\x02\u063E\u063F\x07C\x02\x02\u063F\u0640\x07T\x02\x02\u0640\u0641" + + "\x07V\x02\x02\u0641\u0642\x07K\x02\x02\u0642\u0643\x07V\x02\x02\u0643" + + "\u0644\x07K\x02\x02\u0644\u0645\x07Q\x02\x02\u0645\u0646\x07P\x02\x02" + + "\u0646\u0122\x03\x02\x02\x02\u0647\u0648\x07R\x02\x02\u0648\u0649\x07" + + "C\x02\x02\u0649\u064A\x07T\x02\x02\u064A\u064B\x07V\x02\x02\u064B\u064C" + + "\x07K\x02\x02\u064C\u064D\x07V\x02\x02\u064D\u064E\x07K\x02\x02\u064E" + + "\u064F\x07Q\x02\x02\u064F\u0650\x07P\x02\x02\u0650\u0651\x07U\x02\x02" + + "\u0651\u0124\x03\x02\x02\x02\u0652\u0653\x07R\x02\x02\u0653\u0654\x07" + + "C\x02\x02\u0654\u0655\x07T\x02\x02\u0655\u0656\x07S\x02\x02\u0656\u0657" + + "\x07W\x02\x02\u0657\u0658\x07G\x02\x02\u0658\u0659\x07V\x02\x02\u0659" + + "\u0126\x03\x02\x02\x02\u065A\u065B\x07R\x02\x02\u065B\u065C\x07Q\x02\x02" + + "\u065C\u065D\x07U\x02\x02\u065D\u065E\x07K\x02\x02\u065E\u065F\x07V\x02" + + "\x02\u065F\u0660\x07K\x02\x02\u0660\u0661\x07Q\x02\x02\u0661\u0662\x07" + + "P\x02\x02\u0662\u0128\x03\x02\x02\x02\u0663\u0664\x07R\x02\x02\u0664\u0665" + + "\x07T\x02\x02\u0665\u0666\x07G\x02\x02\u0666\u0667\x07E\x02\x02\u0667" + + "\u0668\x07G\x02\x02\u0668\u0669\x07F\x02\x02\u0669\u066A\x07K\x02\x02" + + "\u066A\u066B\x07P\x02\x02\u066B\u066C\x07I\x02\x02\u066C\u012A\x03\x02" + + "\x02\x02\u066D\u066E\x07R\x02\x02\u066E\u066F\x07T\x02\x02\u066F\u0670" + + "\x07K\x02\x02\u0670\u0671\x07O\x02\x02\u0671\u0672\x07C\x02\x02\u0672" + + "\u0673\x07T\x02\x02\u0673\u0674\x07[\x02\x02\u0674\u012C\x03\x02\x02\x02" + + "\u0675\u0676\x07T\x02\x02\u0676\u0677\x07G\x02\x02\u0677\u0678\x07R\x02" + + "\x02\u0678\u0679\x07N\x02\x02\u0679\u067A\x07K\x02\x02\u067A\u067B\x07" + + "E\x02\x02\u067B\u067C\x07C\x02\x02\u067C\u067D\x07V\x02\x02\u067D\u067E" + + "\x07K\x02\x02\u067E\u067F\x07Q\x02\x02\u067F\u0680\x07P\x02\x02\u0680" + + "\u012E\x03\x02\x02\x02\u0681\u0682\x07R\x02\x02\u0682\u0683\x07T\x02\x02" + + "\u0683\u0684\x07K\x02\x02\u0684\u0685\x07X\x02\x02\u0685\u0686\x07K\x02" + + "\x02\u0686\u0687\x07N\x02\x02\u0687\u0688\x07G\x02\x02\u0688\u0689\x07" + + "I\x02\x02\u0689\u068A\x07G\x02\x02\u068A\u068B\x07U\x02\x02\u068B\u0130" + + "\x03\x02\x02\x02\u068C\u068D\x07R\x02\x02\u068D\u068E\x07T\x02\x02\u068E" + + "\u068F\x07Q\x02\x02\u068F\u0690\x07R\x02\x02\u0690\u0691\x07G\x02\x02" + + "\u0691\u0692\x07T\x02\x02\u0692\u0693\x07V\x02\x02\u0693\u0694\x07K\x02" + + "\x02\u0694\u0695\x07G\x02\x02\u0695\u0696\x07U\x02\x02\u0696\u0132\x03" + + "\x02\x02\x02\u0697\u0698\x07T\x02\x02\u0698\u0699\x07C\x02\x02\u0699\u069A" + + "\x07P\x02\x02\u069A\u069B\x07I\x02\x02\u069B\u069C\x07G\x02\x02\u069C" + + "\u0134\x03\x02\x02\x02\u069D\u069E\x07T\x02\x02\u069E\u069F\x07G\x02\x02" + + "\u069F\u06A0\x07E\x02\x02\u06A0\u06A1\x07Q\x02\x02\u06A1\u06A2\x07X\x02" + + "\x02\u06A2\u06A3\x07G\x02\x02\u06A3\u06A4\x07T\x02\x02\u06A4\u0136\x03" + + "\x02\x02\x02\u06A5\u06A6\x07T\x02\x02\u06A6\u06A7\x07G\x02\x02\u06A7\u06A8" + + "\x07P\x02\x02\u06A8\u06A9\x07C\x02\x02\u06A9\u06AA\x07O\x02\x02\u06AA" + + "\u06AB\x07G\x02\x02\u06AB\u0138\x03\x02\x02\x02\u06AC\u06AD\x07T\x02\x02" + + "\u06AD\u06AE\x07G\x02\x02\u06AE\u06AF\x07R\x02\x02\u06AF\u06B0\x07G\x02" + + "\x02\u06B0\u06B1\x07C\x02\x02\u06B1\u06B2\x07V\x02\x02\u06B2\u06B3\x07" + + "C\x02\x02\u06B3\u06B4\x07D\x02\x02\u06B4\u06B5\x07N\x02\x02\u06B5\u06B6" + + "\x07G\x02\x02\u06B6\u013A\x03\x02\x02\x02\u06B7\u06B8\x07T\x02\x02\u06B8" + + "\u06B9\x07G\x02\x02\u06B9\u06BA\x07R\x02\x02\u06BA\u06BB\x07N\x02\x02" + + "\u06BB\u06BC\x07C\x02\x02\u06BC\u06BD\x07E\x02\x02\u06BD\u06BE\x07G\x02" + + "\x02\u06BE\u013C\x03\x02\x02\x02\u06BF\u06C0\x07T\x02\x02\u06C0\u06C1" + + "\x07G\x02\x02\u06C1\u06C2\x07U\x02\x02\u06C2\u06C3\x07V\x02\x02\u06C3" + + "\u06C4\x07T\x02\x02\u06C4\u06C5\x07K\x02\x02\u06C5\u06C6\x07E\x02\x02" + + "\u06C6\u06C7\x07V\x02\x02\u06C7\u013E\x03\x02\x02\x02\u06C8\u06C9\x07" + + "T\x02\x02\u06C9\u06CA\x07G\x02\x02\u06CA\u06CB\x07V\x02\x02\u06CB\u06CC" + + "\x07W\x02\x02\u06CC\u06CD\x07T\x02\x02\u06CD\u06CE\x07P\x02\x02\u06CE" + + "\u06CF\x07U\x02\x02\u06CF\u0140\x03\x02\x02\x02\u06D0\u06D1\x07T\x02\x02" + + "\u06D1\u06D2\x07G\x02\x02\u06D2\u06D3\x07X\x02\x02\u06D3\u06D4\x07Q\x02" + + "\x02\u06D4\u06D5\x07M\x02\x02\u06D5\u06D6\x07G\x02\x02\u06D6\u0142\x03" + + "\x02\x02\x02\u06D7\u06D8\x07T\x02\x02\u06D8\u06D9\x07G\x02\x02\u06D9\u06DA" + + "\x07H\x02\x02\u06DA\u06DB\x07T\x02\x02\u06DB\u06DC\x07G\x02\x02\u06DC" + + "\u06DD\x07U\x02\x02\u06DD\u06DE\x07J\x02\x02\u06DE\u0144\x03\x02\x02\x02" + + "\u06DF\u06E0\x07T\x02\x02\u06E0\u06E1\x07G\x02\x02\u06E1\u06E2\x07I\x02" + + "\x02\u06E2\u06E3\x07G\x02\x02\u06E3\u06E4\x07Z\x02\x02\u06E4\u06E5\x07" + + "R\x02\x02\u06E5\u0146\x03\x02\x02\x02\u06E6\u06E7\x07T\x02\x02\u06E7\u06E8" + + "\x07N\x02\x02\u06E8\u06E9\x07K\x02\x02\u06E9\u06EA\x07M\x02\x02\u06EA" + + "\u06EB\x07G\x02\x02\u06EB\u0148\x03\x02\x02\x02\u06EC\u06ED\x07T\x02\x02" + + "\u06ED\u06EE\x07K\x02\x02\u06EE\u06EF\x07I\x02\x02\u06EF\u06F0\x07J\x02" + + "\x02\u06F0\u06F1\x07V\x02\x02\u06F1\u014A\x03\x02\x02\x02\u06F2\u06F3" + + "\x07T\x02\x02\u06F3\u06F4\x07Q\x02\x02\u06F4\u06F5\x07N\x02\x02\u06F5" + + "\u06F6\x07G\x02\x02\u06F6\u014C\x03\x02\x02\x02\u06F7\u06F8\x07T\x02\x02" + + "\u06F8\u06F9\x07Q\x02\x02\u06F9\u06FA\x07N\x02\x02\u06FA\u06FB\x07G\x02" + + "\x02\u06FB\u06FC\x07U\x02\x02\u06FC\u014E\x03\x02\x02\x02\u06FD\u06FE" + + "\x07T\x02\x02\u06FE\u06FF\x07Q\x02\x02\u06FF\u0700\x07Y\x02\x02\u0700" + + "\u0150\x03\x02\x02\x02\u0701\u0702\x07T\x02\x02\u0702\u0703\x07Q\x02\x02" + + "\u0703\u0704\x07Y\x02\x02\u0704\u0705\x07U\x02\x02\u0705\u0152\x03\x02" + + "\x02\x02\u0706\u0707\x07U\x02\x02\u0707\u0708\x07E\x02\x02\u0708\u0709" + + "\x07J\x02\x02\u0709\u070A\x07G\x02\x02\u070A\u070B\x07O\x02\x02\u070B" + + "\u070C\x07C\x02\x02\u070C\u0154\x03\x02\x02\x02\u070D\u070E\x07U\x02\x02" + + "\u070E\u070F\x07E\x02\x02\u070F\u0710\x07J\x02\x02\u0710\u0711\x07G\x02" + + "\x02\u0711\u0712\x07O\x02\x02\u0712\u0713\x07C\x02\x02\u0713\u0714\x07" + + "U\x02\x02\u0714\u0156\x03\x02\x02\x02\u0715\u0716\x07U\x02\x02\u0716\u0717" + + "\x07G\x02\x02\u0717\u0718\x07E\x02\x02\u0718\u0719\x07Q\x02\x02\u0719" + + "\u071A\x07P\x02\x02\u071A\u071B\x07F\x02\x02\u071B\u0158\x03\x02\x02\x02" + + "\u071C\u071D\x07U\x02\x02\u071D\u071E\x07G\x02\x02\u071E\u071F\x07E\x02" + + "\x02\u071F\u0720\x07Q\x02\x02\u0720\u0721\x07P\x02\x02\u0721\u0722\x07" + + "F\x02\x02\u0722\u0723\x07U\x02\x02\u0723\u015A\x03\x02\x02\x02\u0724\u0725" + + "\x07U\x02\x02\u0725\u0726\x07G\x02\x02\u0726\u0727\x07N\x02\x02\u0727" + + "\u0728\x07G\x02\x02\u0728\u0729\x07E\x02\x02\u0729\u072A\x07V\x02\x02" + + "\u072A\u015C\x03\x02\x02\x02\u072B\u072C\x07U\x02\x02\u072C\u072D\x07" + + "G\x02\x02\u072D\u072E\x07T\x02\x02\u072E\u072F\x07F\x02\x02\u072F\u0730" + + "\x07G\x02\x02\u0730\u0731\x07R\x02\x02\u0731\u0732\x07T\x02\x02\u0732" + + "\u0733\x07Q\x02\x02\u0733\u0734\x07R\x02\x02\u0734\u0735\x07G\x02\x02" + + "\u0735\u0736\x07T\x02\x02\u0736\u0737\x07V\x02\x02\u0737\u0738\x07K\x02" + + "\x02\u0738\u0739\x07G\x02\x02\u0739\u073A\x07U\x02\x02\u073A\u015E\x03" + + "\x02\x02\x02\u073B\u073C\x07U\x02\x02\u073C\u073D\x07G\x02\x02\u073D\u073E" + + "\x07V\x02\x02\u073E\u0160\x03\x02\x02\x02\u073F\u0740\x07U\x02\x02\u0740" + + "\u0741\x07G\x02\x02\u0741\u0742\x07O\x02\x02\u0742\u0743\x07K\x02\x02" + + "\u0743\u0162\x03\x02\x02\x02\u0744\u0745\x07U\x02\x02\u0745\u0746\x07" + + "G\x02\x02\u0746\u0747\x07T\x02\x02\u0747\u0748\x07X\x02\x02\u0748\u0749" + + "\x07G\x02\x02\u0749\u074A\x07T\x02\x02\u074A\u0164\x03\x02\x02\x02\u074B" + + "\u074C\x07U\x02\x02\u074C\u074D\x07J\x02\x02\u074D\u074E\x07Q\x02\x02" + + "\u074E\u074F\x07Y\x02\x02\u074F\u0166\x03\x02\x02\x02\u0750\u0751\x07" + + "U\x02\x02\u0751\u0752\x07J\x02\x02\u0752\u0753\x07W\x02\x02\u0753\u0754" + + "\x07V\x02\x02\u0754\u0755\x07F\x02\x02\u0755\u0756\x07Q\x02\x02\u0756" + + "\u0757\x07Y\x02\x02\u0757\u0758\x07P\x02\x02\u0758\u0168\x03\x02\x02\x02" + + "\u0759\u075A\x07U\x02\x02\u075A\u075B\x07Q\x02\x02\u075B\u075C\x07O\x02" + + "\x02\u075C\u075D\x07G\x02\x02\u075D\u016A\x03\x02\x02\x02\u075E\u075F" + + "\x07U\x02\x02\u075F\u0760\x07V\x02\x02\u0760\u0761\x07C\x02\x02\u0761" + + "\u0762\x07V\x02\x02\u0762\u0763\x07U\x02\x02\u0763\u016C\x03\x02\x02\x02" + + "\u0764\u0765\x07U\x02\x02\u0765\u0766\x07V\x02\x02\u0766\u0767\x07T\x02" + + "\x02\u0767\u0768\x07W\x02\x02\u0768\u0769\x07E\x02\x02\u0769\u076A\x07" + + "V\x02\x02\u076A\u016E\x03\x02\x02\x02\u076B\u076C\x07U\x02\x02\u076C\u076D" + + "\x07V\x02\x02\u076D\u076E\x07T\x02\x02\u076E\u076F\x07C\x02\x02\u076F" + + "\u0770\x07K\x02\x02\u0770\u0771\x07I\x02\x02\u0771\u0772\x07J\x02\x02" + + "\u0772\u0773\x07V\x02\x02\u0773\u0774\x07a\x02\x02\u0774\u0775\x07L\x02" + + "\x02\u0775\u0776\x07Q\x02\x02\u0776\u0777\x07K\x02\x02\u0777\u0778\x07" + + "P\x02\x02\u0778\u0170\x03\x02\x02\x02\u0779\u077A\x07U\x02\x02\u077A\u077B" + + "\x07W\x02\x02\u077B\u077C\x07D\x02\x02\u077C\u077D\x07U\x02\x02\u077D" + + "\u077E\x07V\x02\x02\u077E\u077F\x07T\x02\x02\u077F\u0780\x07K\x02\x02" + + "\u0780\u0781\x07P\x02\x02\u0781\u0782\x07I\x02\x02\u0782\u0172\x03\x02" + + "\x02\x02\u0783\u0784\x07U\x02\x02\u0784\u0785\x07[\x02\x02\u0785\u0786" + + "\x07U\x02\x02\u0786\u0787\x07V\x02\x02\u0787\u0788\x07G\x02\x02\u0788" + + "\u0789\x07O\x02\x02\u0789\u0174\x03\x02\x02\x02\u078A\u078B\x07U\x02\x02" + + "\u078B\u078C\x07[\x02\x02\u078C\u078D\x07O\x02\x02\u078D\u078E\x07D\x02" + + "\x02\u078E\u078F\x07Q\x02\x02\u078F\u0790\x07N\x02\x02\u0790\u0176\x03" + + "\x02\x02\x02\u0791\u0792\x07U\x02\x02\u0792\u0793\x07G\x02\x02\u0793\u0794" + + "\x07T\x02\x02\u0794\u0795\x07K\x02\x02\u0795\u0796\x07C\x02\x02\u0796" + + "\u0797\x07N\x02\x02\u0797\u0798\x07K\x02\x02\u0798\u0799\x07\\\x02\x02" + + "\u0799\u079A\x07G\x02\x02\u079A\u079B\x07a\x02\x02\u079B\u079C\x07H\x02" + + "\x02\u079C\u079D\x07P\x02\x02\u079D\u0178\x03\x02\x02\x02\u079E\u079F" + + "\x07V\x02\x02\u079F\u07A0\x07C\x02\x02\u07A0\u07A1\x07D\x02\x02\u07A1" + + "\u07A2\x07N\x02\x02\u07A2\u07A3\x07G\x02\x02\u07A3\u017A\x03\x02\x02\x02" + + "\u07A4\u07A5\x07V\x02\x02\u07A5\u07A6\x07C\x02\x02\u07A6\u07A7\x07D\x02" + + "\x02\u07A7\u07A8\x07N\x02\x02\u07A8\u07A9\x07G\x02\x02\u07A9\u07AA\x07" + + "U\x02\x02\u07AA\u017C\x03\x02\x02\x02\u07AB\u07AC\x07V\x02\x02\u07AC\u07AD" + + "\x07C\x02\x02\u07AD\u07AE\x07D\x02\x02\u07AE\u07AF\x07N\x02\x02\u07AF" + + "\u07B0\x07G\x02\x02\u07B0\u07B1\x07U\x02\x02\u07B1\u07B2\x07C\x02\x02" + + "\u07B2\u07B3\x07O\x02\x02\u07B3\u07B4\x07R\x02\x02\u07B4\u07B5\x07N\x02" + + "\x02\u07B5\u07B6\x07G\x02\x02\u07B6\u017E\x03\x02\x02\x02\u07B7\u07B8" + + "\x07V\x02\x02\u07B8\u07B9\x07G\x02\x02\u07B9\u07BA\x07T\x02\x02\u07BA" + + "\u07BB\x07O\x02\x02\u07BB\u07BC\x07K\x02\x02\u07BC\u07BD\x07P\x02\x02" + + "\u07BD\u07BE\x07C\x02\x02\u07BE\u07BF\x07V\x02\x02\u07BF\u07C0\x07G\x02" + + "\x02\u07C0\u07C1\x07F\x02\x02\u07C1\u07C2\x07\"\x02\x02\u07C2\u0180\x03" + + "\x02\x02\x02\u07C3\u07C4\x07V\x02\x02\u07C4\u07C5\x07J\x02\x02\u07C5\u07C6" + + "\x07G\x02\x02\u07C6\u07C7\x07P\x02\x02\u07C7\u0182\x03\x02\x02\x02\u07C8" + + "\u07C9\x07V\x02\x02\u07C9\u07CA\x07Q\x02\x02\u07CA\u0184\x03\x02\x02\x02" + + "\u07CB\u07CC\x07V\x02\x02\u07CC\u07CD\x07T\x02\x02\u07CD\u07CE\x07W\x02" + + "\x02\u07CE\u07CF\x07G\x02\x02\u07CF\u0186\x03\x02\x02\x02\u07D0\u07D1" + + "\x07V\x02\x02\u07D1\u07D2\x07T\x02\x02\u07D2\u07D3\x07[\x02\x02\u07D3" + + "\u07D4\x07a\x02\x02\u07D4\u07D5\x07E\x02\x02\u07D5\u07D6\x07C\x02\x02" + + "\u07D6\u07D7\x07U\x02\x02\u07D7\u07D8\x07V\x02\x02\u07D8\u0188\x03\x02" + + "\x02\x02\u07D9\u07DA\x07V\x02\x02\u07DA\u07DB\x07T\x02\x02\u07DB\u07DC" + + "\x07W\x02\x02\u07DC\u07DD\x07P\x02\x02\u07DD\u07DE\x07E\x02\x02\u07DE" + + "\u07DF\x07C\x02\x02\u07DF\u07E0\x07V\x02\x02\u07E0\u07E1\x07G\x02\x02" + + "\u07E1\u018A\x03\x02\x02\x02\u07E2\u07E3\x07W\x02\x02\u07E3\u07E4\x07" + + "P\x02\x02\u07E4\u07E5\x07E\x02\x02\u07E5\u07E6\x07C\x02\x02\u07E6\u07E7" + + "\x07E\x02\x02\u07E7\u07E8\x07J\x02\x02\u07E8\u07E9\x07G\x02\x02\u07E9" + + "\u07EA\x07F\x02\x02\u07EA\u018C\x03\x02\x02\x02\u07EB\u07EC\x07W\x02\x02" + + "\u07EC\u07ED\x07G\x02\x02\u07ED\u07EE\x07U\x02\x02\u07EE\u07EF\x07E\x02" + + "\x02\u07EF\u07F0\x07C\x02\x02\u07F0\u07F1\x07R\x02\x02\u07F1\u07F2\x07" + + "G\x02\x02\u07F2\u018E\x03\x02\x02\x02\u07F3\u07F4\x07W\x02\x02\u07F4\u07F5" + + "\x07P\x02\x02\u07F5\u07F6\x07D\x02\x02\u07F6\u07F7\x07Q\x02\x02\u07F7" + + "\u07F8\x07W\x02\x02\u07F8\u07F9\x07P\x02\x02\u07F9\u07FA\x07F\x02\x02" + + "\u07FA\u07FB\x07G\x02\x02\u07FB\u07FC\x07F\x02\x02\u07FC\u0190\x03\x02" + + "\x02\x02\u07FD\u07FE\x07W\x02\x02\u07FE\u07FF\x07P\x02\x02\u07FF\u0800" + + "\x07K\x02\x02\u0800\u0801\x07Q\x02\x02\u0801\u0802\x07P\x02\x02\u0802" + + "\u0192\x03\x02\x02\x02\u0803\u0804\x07W\x02\x02\u0804\u0805\x07P\x02\x02" + + "\u0805\u0806\x07P\x02\x02\u0806\u0807\x07G\x02\x02\u0807\u0808\x07U\x02" + + "\x02\u0808\u0809\x07V\x02\x02\u0809\u0194\x03\x02\x02\x02\u080A\u080B" + + "\x07W\x02\x02\u080B\u080C\x07P\x02\x02\u080C\u080D\x07U\x02\x02\u080D" + + "\u080E\x07G\x02\x02\u080E\u080F\x07V\x02\x02\u080F\u0196\x03\x02\x02\x02" + + "\u0810\u0811\x07W\x02\x02\u0811\u0812\x07U\x02\x02\u0812\u0813\x07G\x02" + + "\x02\u0813\u0198\x03\x02\x02\x02\u0814\u0815\x07W\x02\x02\u0815\u0816" + + "\x07U\x02\x02\u0816\u0817\x07G\x02\x02\u0817\u0818\x07T\x02\x02\u0818" + + "\u019A\x03\x02\x02\x02\u0819\u081A\x07W\x02\x02\u081A\u081B\x07U\x02\x02" + + "\u081B\u081C\x07K\x02\x02\u081C\u081D\x07P\x02\x02\u081D\u081E\x07I\x02" + + "\x02\u081E\u019C\x03\x02\x02\x02\u081F\u0820\x07W\x02\x02\u0820\u0821" + + "\x07R\x02\x02\u0821\u0822\x07F\x02\x02\u0822\u0823\x07C\x02\x02\u0823" + + "\u0824\x07V\x02\x02\u0824\u0825\x07G\x02\x02\u0825\u0826\x07a\x02\x02" + + "\u0826\u0827\x07H\x02\x02\u0827\u0828\x07P\x02\x02\u0828\u019E\x03\x02" + + "\x02\x02\u0829\u082A\x07W\x02\x02\u082A\u082B\x07R\x02\x02\u082B\u082C" + + "\x07U\x02\x02\u082C\u082D\x07G\x02\x02\u082D\u082E\x07T\x02\x02\u082E" + + "\u082F\x07V\x02\x02\u082F\u01A0\x03\x02\x02\x02\u0830\u0831\x07W\x02\x02" + + "\u0831\u0832\x07T\x02\x02\u0832\u0833\x07K\x02\x02\u0833\u01A2\x03\x02" + + "\x02\x02\u0834\u0835\x07X\x02\x02\u0835\u0836\x07C\x02\x02\u0836\u0837" + + "\x07N\x02\x02\u0837\u0838\x07W\x02\x02\u0838\u0839\x07G\x02\x02\u0839" + + "\u01A4\x03\x02\x02\x02\u083A\u083B\x07X\x02\x02\u083B\u083C\x07C\x02\x02" + + "\u083C\u083D\x07N\x02\x02\u083D\u083E\x07W\x02\x02\u083E\u083F\x07G\x02" + + "\x02\u083F\u0840\x07U\x02\x02\u0840\u01A6\x03\x02\x02\x02\u0841\u0842" + + "\x07X\x02\x02\u0842\u0843\x07K\x02\x02\u0843\u0844\x07G\x02\x02\u0844" + + "\u0845\x07Y\x02\x02\u0845\u01A8\x03\x02\x02\x02\u0846\u0847\x07X\x02\x02" + + "\u0847\u0848\x07K\x02\x02\u0848\u0849\x07G\x02\x02\u0849\u084A\x07Y\x02" + + "\x02\u084A\u084B\x07U\x02\x02\u084B\u01AA\x03\x02\x02\x02\u084C\u084D" + + "\x07Y\x02\x02\u084D\u084E\x07J\x02\x02\u084E\u084F\x07G\x02\x02\u084F" + + "\u0850\x07P\x02\x02\u0850\u01AC\x03\x02\x02\x02\u0851\u0852\x07Y\x02\x02" + + "\u0852\u0853\x07J\x02\x02\u0853\u0854\x07G\x02\x02\u0854\u0855\x07T\x02" + + "\x02\u0855\u0856\x07G\x02\x02\u0856\u01AE\x03\x02\x02\x02\u0857\u0858" + + "\x07Y\x02\x02\u0858\u0859\x07K\x02\x02\u0859\u085A\x07V\x02\x02\u085A" + + "\u085B\x07J\x02\x02\u085B\u01B0\x03\x02\x02\x02\u085C\u085D\x07[\x02\x02" + + "\u085D\u085E\x07G\x02\x02\u085E\u085F\x07C\x02\x02\u085F\u0860\x07T\x02" + + "\x02\u0860\u01B2\x03\x02\x02\x02\u0861\u0862\x07[\x02\x02\u0862\u0863" + + "\x07G\x02\x02\u0863\u0864\x07C\x02\x02\u0864\u0865\x07T\x02\x02\u0865" + + "\u0866\x07U\x02\x02\u0866\u01B4\x03\x02\x02\x02\u0867\u0868\x07V\x02\x02" + + "\u0868\u0869\x07G\x02\x02\u0869\u086A\x07Z\x02\x02\u086A\u086B\x07V\x02" + + "\x02\u086B\u086C\x07H\x02\x02\u086C\u086D\x07K\x02\x02\u086D\u086E\x07" + + "N\x02\x02\u086E\u086F\x07G\x02\x02\u086F\u01B6\x03\x02\x02\x02\u0870\u0871" + + "\x07Q\x02\x02\u0871\u0872\x07T\x02\x02\u0872\u0873\x07E\x02\x02\u0873" + + "\u01B8\x03\x02\x02\x02\u0874\u0875\x07C\x02\x02\u0875\u0876\x07X\x02\x02" + + "\u0876\u0877\x07T\x02\x02\u0877\u0878\x07Q\x02\x02\u0878\u01BA\x03\x02" + + "\x02\x02\u0879\u087A\x07U\x02\x02\u087A\u087B\x07G\x02\x02\u087B\u087C" + + "\x07S\x02\x02\u087C\u087D\x07W\x02\x02\u087D\u087E\x07G\x02\x02\u087E" + + "\u087F\x07P\x02\x02\u087F\u0880\x07E\x02\x02\u0880\u0881\x07G\x02\x02" + + "\u0881\u0882\x07H\x02\x02\u0882\u0883\x07K\x02\x02\u0883\u0884\x07N\x02" + + "\x02\u0884\u0885\x07G\x02\x02\u0885\u01BC\x03\x02\x02\x02\u0886\u0887" + + "\x07T\x02\x02\u0887\u0888\x07E\x02\x02\u0888\u0889\x07H\x02\x02\u0889" + + "\u088A\x07K\x02\x02\u088A\u088B\x07N\x02\x02\u088B\u088C\x07G\x02\x02" + + "\u088C\u01BE\x03\x02\x02\x02\u088D\u088E\x07T\x02\x02\u088E\u088F\x07" + + "G\x02\x02\u088F\u0890\x07H\x02\x02\u0890\u0891\x07G\x02\x02\u0891\u0892" + + "\x07T\x02\x02\u0892\u0893\x07G\x02\x02\u0893\u0894\x07P\x02\x02\u0894" + + "\u0895\x07E\x02\x02\u0895\u0896\x07G\x02\x02\u0896\u0897\x07U\x02\x02" + + "\u0897\u01C0\x03\x02\x02\x02\u0898\u0899\x07P\x02\x02\u0899\u089A\x07" + + "Q\x02\x02\u089A\u089B\x07X\x02\x02\u089B\u089C\x07C\x02\x02\u089C\u089D" + + "\x07N\x02\x02\u089D\u089E\x07K\x02\x02\u089E\u089F\x07F\x02\x02\u089F" + + "\u08A0\x07C\x02\x02\u08A0\u08A1\x07V\x02\x02\u08A1\u08A2\x07G\x02\x02" + + "\u08A2\u01C2\x03\x02\x02\x02\u08A3\u08A4\x07T\x02\x02\u08A4\u08A5\x07" + + "G\x02\x02\u08A5\u08A6\x07N\x02\x02\u08A6\u08A7\x07[\x02\x02\u08A7\u01C4" + + "\x03\x02\x02\x02\u08A8\u08A9\x07)\x02\x02\u08A9\u08AA\x07P\x02\x02\u08AA" + + "\u08AB\x07W\x02\x02\u08AB\u08AC\x07O\x02\x02\u08AC\u08AD\x07F\x02\x02" + + "\u08AD\u08AE\x07X\x02\x02\u08AE\u08AF\x07U\x02\x02\u08AF\u08B0\x07)\x02" + + "\x02\u08B0\u01C6\x03\x02\x02\x02\u08B1\u08B2\x07)\x02\x02\u08B2\u08B3" + + "\x07P\x02\x02\u08B3\u08B4\x07W\x02\x02\u08B4\u08B5\x07O\x02\x02\u08B5" + + "\u08B6\x07P\x02\x02\u08B6\u08B7\x07W\x02\x02\u08B7\u08B8\x07N\x02\x02" + + "\u08B8\u08B9\x07N\x02\x02\u08B9\u08BA\x07U\x02\x02\u08BA\u08BB\x07)\x02" + + "\x02\u08BB\u01C8\x03\x02\x02\x02\u08BC\u08BD\x07)\x02\x02\u08BD\u08BE" + + "\x07C\x02\x02\u08BE\u08BF\x07X\x02\x02\u08BF\u08C0\x07I\x02\x02\u08C0" + + "\u08C1\x07U\x02\x02\u08C1\u08C2\x07K\x02\x02\u08C2\u08C3\x07\\\x02\x02" + + "\u08C3\u08C4\x07G\x02\x02\u08C4\u08C5\x07)\x02\x02\u08C5\u01CA\x03\x02" + + "\x02\x02\u08C6\u08C7\x07)\x02\x02\u08C7\u08C8\x07O\x02\x02\u08C8\u08C9" + + "\x07C\x02\x02\u08C9\u08CA\x07Z\x02\x02\u08CA\u08CB\x07U\x02\x02\u08CB" + + "\u08CC\x07K\x02\x02\u08CC\u08CD\x07\\\x02\x02\u08CD\u08CE\x07G\x02\x02" + + "\u08CE\u08CF\x07)\x02\x02\u08CF\u01CC\x03\x02\x02\x02\u08D0\u08D1\x07" + + "?\x02\x02\u08D1\u01CE\x03\x02\x02\x02\u08D2\u08D3\x07>\x02\x02\u08D3\u08D7" + + "\x07@\x02\x02\u08D4\u08D5\x07#\x02\x02\u08D5\u08D7\x07?\x02\x02\u08D6" + + "\u08D2\x03\x02\x02\x02\u08D6\u08D4\x03\x02\x02\x02\u08D7\u01D0\x03\x02" + + "\x02\x02\u08D8\u08D9\x07>\x02\x02\u08D9\u01D2\x03\x02\x02\x02\u08DA\u08DB" + + "\x07>\x02\x02\u08DB\u08DC\x07?\x02\x02\u08DC\u01D4\x03\x02\x02\x02\u08DD" + + "\u08DE\x07@\x02\x02\u08DE\u01D6\x03\x02\x02\x02\u08DF\u08E0\x07@\x02\x02" + + "\u08E0\u08E1\x07?\x02\x02\u08E1\u01D8\x03\x02\x02\x02\u08E2\u08E3\x07" + + "-\x02\x02\u08E3\u01DA\x03\x02\x02\x02\u08E4\u08E5\x07/\x02\x02\u08E5\u01DC" + + "\x03\x02\x02\x02\u08E6\u08E7\x07,\x02\x02\u08E7\u01DE\x03\x02\x02\x02" + + "\u08E8\u08E9\x071\x02\x02\u08E9\u01E0\x03\x02\x02\x02\u08EA\u08EB\x07" + + "\'\x02\x02\u08EB\u01E2\x03\x02\x02\x02\u08EC\u08ED\x07~\x02\x02\u08ED" + + "\u08EE\x07~\x02\x02\u08EE\u01E4\x03\x02\x02\x02\u08EF\u08F0\x070\x02\x02" + + "\u08F0\u01E6\x03\x02\x02\x02\u08F1\u08F2\x07=\x02\x02\u08F2\u01E8\x03" + + "\x02\x02\x02\u08F3\u08F4\x07.\x02\x02\u08F4\u01EA\x03\x02\x02\x02\u08F5" + + "\u08F6\x07<\x02\x02\u08F6\u01EC\x03\x02\x02\x02\u08F7\u08F8\x07*\x02\x02" + + "\u08F8\u01EE\x03\x02\x02\x02\u08F9\u08FA\x07+\x02\x02\u08FA\u01F0\x03" + + "\x02\x02\x02\u08FB\u08FC\x07]\x02\x02\u08FC\u01F2\x03\x02\x02\x02\u08FD" + + "\u08FE\x07_\x02\x02\u08FE\u01F4\x03\x02\x02\x02\u08FF\u0900\x07}\x02\x02" + + "\u0900\u01F6\x03\x02\x02\x02\u0901\u0902\x07\x7F\x02\x02\u0902\u01F8\x03" + + "\x02\x02\x02\u0903\u0904\x07~\x02\x02\u0904\u01FA\x03\x02\x02\x02\u0905" + + "\u0906\x07A\x02\x02\u0906\u01FC\x03\x02\x02\x02\u0907\u0908\x07/\x02\x02" + + "\u0908\u0909\x07@\x02\x02\u0909\u01FE\x03\x02\x02\x02\u090A\u0910\x07" + + ")\x02\x02\u090B\u090F\n\x02\x02\x02\u090C\u090D\x07)\x02\x02\u090D\u090F" + + "\x07)\x02\x02\u090E\u090B\x03\x02\x02\x02\u090E\u090C\x03\x02\x02\x02" + + "\u090F\u0912\x03\x02\x02\x02\u0910\u090E\x03\x02\x02\x02\u0910\u0911\x03" + + "\x02\x02\x02\u0911\u0913\x03\x02\x02\x02\u0912\u0910\x03\x02\x02\x02"; + private static readonly _serializedATNSegment4: string = + "\u0913\u091F\x07)\x02\x02\u0914\u091A\x07$\x02\x02\u0915\u0919\n\x03\x02" + + "\x02\u0916\u0917\x07$\x02\x02\u0917\u0919\x07$\x02\x02\u0918\u0915\x03" + + "\x02\x02\x02\u0918\u0916\x03\x02\x02\x02\u0919\u091C\x03\x02\x02\x02\u091A" + + "\u0918\x03\x02\x02\x02\u091A\u091B\x03\x02\x02\x02\u091B\u091D\x03\x02" + + "\x02\x02\u091C\u091A\x03\x02\x02\x02\u091D\u091F\x07$\x02\x02\u091E\u090A" + + "\x03\x02\x02\x02\u091E\u0914\x03\x02\x02\x02\u091F\u0200\x03\x02\x02\x02" + + "\u0920\u0921\x07W\x02\x02\u0921\u0922\x07(\x02\x02\u0922\u0923\x07)\x02" + + "\x02\u0923\u0929\x03\x02\x02\x02\u0924\u0928\n\x02\x02\x02\u0925\u0926" + + "\x07)\x02\x02\u0926\u0928\x07)\x02\x02\u0927\u0924\x03\x02\x02\x02\u0927" + + "\u0925\x03\x02\x02\x02\u0928\u092B\x03\x02\x02\x02\u0929\u0927\x03\x02" + + "\x02\x02\u0929\u092A\x03\x02\x02\x02\u092A\u092C\x03\x02\x02\x02\u092B" + + "\u0929\x03\x02\x02\x02\u092C\u092D\x07)\x02\x02\u092D\u0202\x03\x02\x02" + + "\x02\u092E\u092F\x07Z\x02\x02\u092F\u0930\x07)\x02\x02\u0930\u0934\x03" + + "\x02\x02\x02\u0931\u0933\n\x02\x02\x02\u0932\u0931\x03\x02\x02\x02\u0933" + + "\u0936\x03\x02\x02\x02\u0934\u0932\x03\x02\x02\x02\u0934\u0935\x03\x02" + + "\x02\x02\u0935\u0937\x03\x02\x02\x02\u0936\u0934\x03\x02\x02\x02\u0937" + + "\u0938\x07)\x02\x02\u0938\u0204\x03\x02\x02\x02\u0939\u093B\x05\u021B" + + "\u010E\x02\u093A\u0939\x03\x02\x02\x02\u093B\u093C\x03\x02\x02\x02\u093C" + + "\u093A\x03\x02\x02\x02\u093C\u093D\x03\x02\x02\x02\u093D\u0206\x03\x02" + + "\x02\x02\u093E\u0940\x05\u021B\u010E\x02\u093F\u093E\x03\x02\x02\x02\u0940" + + "\u0941\x03\x02\x02\x02\u0941\u093F\x03\x02\x02\x02\u0941\u0942\x03\x02" + + "\x02\x02\u0942\u0943\x03\x02\x02\x02\u0943\u0947\x070\x02\x02\u0944\u0946" + + "\x05\u021B\u010E\x02\u0945\u0944\x03\x02\x02\x02\u0946\u0949\x03\x02\x02" + + "\x02\u0947\u0945\x03\x02\x02\x02\u0947\u0948\x03\x02\x02\x02\u0948\u0951" + + "\x03\x02\x02\x02\u0949\u0947\x03\x02\x02\x02\u094A\u094C\x070\x02\x02" + + "\u094B\u094D\x05\u021B\u010E\x02\u094C\u094B\x03\x02\x02\x02\u094D\u094E" + + "\x03\x02\x02\x02\u094E\u094C\x03\x02\x02\x02\u094E\u094F\x03\x02\x02\x02" + + "\u094F\u0951\x03\x02\x02\x02\u0950\u093F\x03\x02\x02\x02\u0950\u094A\x03" + + "\x02\x02\x02\u0951\u0208\x03\x02\x02\x02\u0952\u0954\x05\u021B\u010E\x02" + + "\u0953\u0952\x03\x02\x02\x02\u0954\u0955\x03\x02\x02\x02\u0955\u0953\x03" + + "\x02\x02\x02\u0955\u0956\x03\x02\x02\x02\u0956\u095E\x03\x02\x02\x02\u0957" + + "\u095B\x070\x02\x02\u0958\u095A\x05\u021B\u010E\x02\u0959\u0958\x03\x02" + + "\x02\x02\u095A\u095D\x03\x02\x02\x02\u095B\u0959\x03\x02\x02\x02\u095B" + + "\u095C\x03\x02\x02\x02\u095C\u095F\x03\x02\x02\x02\u095D\u095B\x03\x02" + + "\x02\x02\u095E\u0957\x03\x02\x02\x02\u095E\u095F\x03\x02\x02\x02\u095F" + + "\u0960\x03\x02\x02\x02\u0960\u0961\x05\u0219\u010D\x02\u0961\u096B\x03" + + "\x02\x02\x02\u0962\u0964\x070\x02\x02\u0963\u0965\x05\u021B\u010E\x02" + + "\u0964\u0963\x03\x02\x02\x02\u0965\u0966\x03\x02\x02\x02\u0966\u0964\x03" + + "\x02\x02\x02\u0966\u0967\x03\x02\x02\x02\u0967\u0968\x03\x02\x02\x02\u0968" + + "\u0969\x05\u0219\u010D\x02\u0969\u096B\x03\x02\x02\x02\u096A\u0953\x03" + + "\x02\x02\x02\u096A\u0962\x03\x02\x02\x02\u096B\u020A\x03\x02\x02\x02\u096C" + + "\u096F\x05\u021D\u010F\x02\u096D\u096F\x07a\x02\x02\u096E\u096C\x03\x02" + + "\x02\x02\u096E\u096D\x03\x02\x02\x02\u096F\u0975\x03\x02\x02\x02\u0970" + + "\u0974\x05\u021D\u010F\x02\u0971\u0974\x05\u021B\u010E\x02\u0972\u0974" + + "\t\x04\x02\x02\u0973\u0970\x03\x02\x02\x02\u0973\u0971\x03\x02\x02\x02" + + "\u0973\u0972\x03\x02\x02\x02\u0974\u0977\x03\x02\x02\x02\u0975\u0973\x03" + + "\x02\x02\x02\u0975\u0976\x03\x02\x02\x02\u0976\u020C\x03\x02\x02\x02\u0977" + + "\u0975\x03\x02\x02\x02\u0978\u097C\x05\u021B\u010E\x02\u0979\u097D\x05" + + "\u021D\u010F\x02\u097A\u097D\x05\u021B\u010E\x02\u097B\u097D\t\x04\x02" + + "\x02\u097C\u0979\x03\x02\x02\x02\u097C\u097A\x03\x02\x02\x02\u097C\u097B" + + "\x03\x02\x02\x02\u097D\u097E\x03\x02\x02\x02\u097E\u097C\x03\x02\x02\x02" + + "\u097E\u097F\x03\x02\x02\x02\u097F\u020E\x03\x02\x02\x02\u0980\u0986\x07" + + "$\x02\x02\u0981\u0985\n\x03\x02\x02\u0982\u0983\x07$\x02\x02\u0983\u0985" + + "\x07$\x02\x02\u0984\u0981\x03\x02\x02\x02\u0984\u0982\x03\x02\x02\x02" + + "\u0985\u0988\x03\x02\x02\x02\u0986\u0984\x03\x02\x02\x02\u0986\u0987\x03" + + "\x02\x02\x02\u0987\u0989\x03\x02\x02\x02\u0988\u0986\x03\x02\x02\x02\u0989" + + "\u098A\x07$\x02\x02\u098A\u0210\x03\x02\x02\x02\u098B\u0991\x07b\x02\x02" + + "\u098C\u0990\n\x05\x02\x02\u098D\u098E\x07b\x02\x02\u098E\u0990\x07b\x02" + + "\x02\u098F\u098C\x03\x02\x02\x02\u098F\u098D\x03\x02\x02\x02\u0990\u0993" + + "\x03\x02\x02\x02\u0991\u098F\x03\x02\x02\x02\u0991\u0992\x03\x02\x02\x02" + + "\u0992\u0994\x03\x02\x02\x02\u0993\u0991\x03\x02\x02\x02\u0994\u0995\x07" + + "b\x02\x02\u0995\u0212\x03\x02\x02\x02\u0996\u0997\x07V\x02\x02\u0997\u0998" + + "\x07K\x02\x02\u0998\u0999\x07O\x02\x02\u0999\u099A\x07G\x02\x02\u099A" + + "\u099B\x03\x02\x02\x02\u099B\u099C\x05\u0223\u0112\x02\u099C\u099D\x07" + + "Y\x02\x02\u099D\u099E\x07K\x02\x02\u099E\u099F\x07V\x02\x02\u099F\u09A0" + + "\x07J\x02\x02\u09A0\u09A1\x03\x02\x02\x02\u09A1\u09A2\x05\u0223\u0112" + + "\x02\u09A2\u09A3\x07V\x02\x02\u09A3\u09A4\x07K\x02\x02\u09A4\u09A5\x07" + + "O\x02\x02\u09A5\u09A6\x07G\x02\x02\u09A6\u09A7\x03\x02\x02\x02\u09A7\u09A8" + + "\x05\u0223\u0112\x02\u09A8\u09A9\x07\\\x02\x02\u09A9\u09AA\x07Q\x02\x02" + + "\u09AA\u09AB\x07P\x02\x02\u09AB\u09AC\x07G\x02\x02\u09AC\u0214\x03\x02" + + "\x02\x02\u09AD\u09AE\x07V\x02\x02\u09AE\u09AF\x07K\x02\x02\u09AF\u09B0" + + "\x07O\x02\x02\u09B0\u09B1\x07G\x02\x02\u09B1\u09B2\x07U\x02\x02\u09B2" + + "\u09B3\x07V\x02\x02\u09B3\u09B4\x07C\x02\x02\u09B4\u09B5\x07O\x02\x02" + + "\u09B5\u09B6\x07R\x02\x02\u09B6\u09B7\x03\x02\x02\x02\u09B7\u09B8\x05" + + "\u0223\u0112\x02\u09B8\u09B9\x07Y\x02\x02\u09B9\u09BA\x07K\x02\x02\u09BA" + + "\u09BB\x07V\x02\x02\u09BB\u09BC\x07J\x02\x02\u09BC\u09BD\x03\x02\x02\x02" + + "\u09BD\u09BE\x05\u0223\u0112\x02\u09BE\u09BF\x07V\x02\x02\u09BF\u09C0" + + "\x07K\x02\x02\u09C0\u09C1\x07O\x02\x02\u09C1\u09C2\x07G\x02\x02\u09C2" + + "\u09C3\x03\x02\x02\x02\u09C3\u09C4\x05\u0223\u0112\x02\u09C4\u09C5\x07" + + "\\\x02\x02\u09C5\u09C6\x07Q\x02\x02\u09C6\u09C7\x07P\x02\x02\u09C7\u09C8" + + "\x07G\x02\x02\u09C8\u0216\x03\x02\x02\x02\u09C9\u09CA\x07F\x02\x02\u09CA" + + "\u09CB\x07Q\x02\x02\u09CB\u09CC\x07W\x02\x02\u09CC\u09CD\x07D\x02\x02" + + "\u09CD\u09CE\x07N\x02\x02\u09CE\u09CF\x07G\x02\x02\u09CF\u09D0\x03\x02" + + "\x02\x02\u09D0\u09D1\x05\u0223\u0112\x02\u09D1\u09D2\x07R\x02\x02\u09D2" + + "\u09D3\x07T\x02\x02\u09D3\u09D4\x07G\x02\x02\u09D4\u09D5\x07E\x02\x02" + + "\u09D5\u09D6\x07K\x02\x02\u09D6\u09D7\x07U\x02\x02\u09D7\u09D8\x07K\x02" + + "\x02\u09D8\u09D9\x07Q\x02\x02\u09D9\u09DA\x07P\x02\x02\u09DA\u0218\x03" + + "\x02\x02\x02\u09DB\u09DD\x07G\x02\x02\u09DC\u09DE\t\x06\x02\x02\u09DD" + + "\u09DC\x03\x02\x02\x02\u09DD\u09DE\x03\x02\x02\x02\u09DE\u09E0\x03\x02" + + "\x02\x02\u09DF\u09E1\x05\u021B\u010E\x02\u09E0\u09DF\x03\x02\x02\x02\u09E1" + + "\u09E2\x03\x02\x02\x02\u09E2\u09E0\x03\x02\x02\x02\u09E2\u09E3\x03\x02" + + "\x02\x02\u09E3\u021A\x03\x02\x02\x02\u09E4\u09E5\t\x07\x02\x02\u09E5\u021C" + + "\x03\x02\x02\x02\u09E6\u09E7\t\b\x02\x02\u09E7\u021E\x03\x02\x02\x02\u09E8" + + "\u09E9\x07/\x02\x02\u09E9\u09EA\x07/\x02\x02\u09EA\u09EE\x03\x02\x02\x02" + + "\u09EB\u09ED\n\t\x02\x02\u09EC\u09EB\x03\x02\x02\x02\u09ED\u09F0\x03\x02" + + "\x02\x02\u09EE\u09EC\x03\x02\x02\x02\u09EE\u09EF\x03\x02\x02\x02\u09EF" + + "\u09F2\x03\x02\x02\x02\u09F0\u09EE\x03\x02\x02\x02\u09F1\u09F3\x07\x0F" + + "\x02\x02\u09F2\u09F1\x03\x02\x02\x02\u09F2\u09F3\x03\x02\x02\x02\u09F3" + + "\u09F5\x03\x02\x02\x02\u09F4\u09F6\x07\f\x02\x02\u09F5\u09F4\x03\x02\x02" + + "\x02\u09F5\u09F6\x03\x02\x02\x02\u09F6\u09F7\x03\x02\x02\x02\u09F7\u09F8" + + "\b\u0110\x02\x02\u09F8\u0220\x03\x02\x02\x02\u09F9\u09FA\x071\x02\x02" + + "\u09FA\u09FB\x07,\x02\x02\u09FB\u09FF\x03\x02\x02\x02\u09FC\u09FE\v\x02" + + "\x02\x02\u09FD\u09FC\x03\x02\x02\x02\u09FE\u0A01\x03\x02\x02\x02\u09FF" + + "\u0A00\x03\x02\x02\x02\u09FF\u09FD\x03\x02\x02\x02\u0A00\u0A02\x03\x02" + + "\x02\x02\u0A01\u09FF\x03\x02\x02\x02\u0A02\u0A03\x07,\x02\x02\u0A03\u0A04" + + "\x071\x02\x02\u0A04\u0A05\x03\x02\x02\x02\u0A05\u0A06\b\u0111\x02\x02" + + "\u0A06\u0222\x03\x02\x02\x02\u0A07\u0A09\t\n\x02\x02\u0A08\u0A07\x03\x02" + + "\x02\x02\u0A09\u0A0A\x03\x02\x02\x02\u0A0A\u0A08\x03\x02\x02\x02\u0A0A" + + "\u0A0B\x03\x02\x02\x02\u0A0B\u0A0C\x03\x02\x02\x02\u0A0C\u0A0D\b\u0112" + + "\x02\x02\u0A0D\u0224\x03\x02\x02\x02&\x02\u08D6\u090E\u0910\u0918\u091A" + + "\u091E\u0927\u0929\u0934\u093C\u0941\u0947\u094E\u0950\u0955\u095B\u095E" + + "\u0966\u096A\u096E\u0973\u0975\u097C\u097E\u0984\u0986\u098F\u0991\u09DD" + + "\u09E2\u09EE\u09F2\u09F5\u09FF\u0A0A\x03\x02\x03\x02"; + public static readonly _serializedATN: string = Utils.join( + [ + ImpalaSqlLexer._serializedATNSegment0, + ImpalaSqlLexer._serializedATNSegment1, + ImpalaSqlLexer._serializedATNSegment2, + ImpalaSqlLexer._serializedATNSegment3, + ImpalaSqlLexer._serializedATNSegment4, + ], + "", + ); + public static __ATN: ATN; + public static get _ATN(): ATN { + if (!ImpalaSqlLexer.__ATN) { + ImpalaSqlLexer.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(ImpalaSqlLexer._serializedATN)); + } + + return ImpalaSqlLexer.__ATN; + } + +} + diff --git a/src/lib/impala/ImpalaSqlParser.interp b/src/lib/impala/ImpalaSqlParser.interp new file mode 100644 index 0000000..db0cc61 --- /dev/null +++ b/src/lib/impala/ImpalaSqlParser.interp @@ -0,0 +1,731 @@ +token literal names: +null +'ADD' +'ALL' +'ANALYTIC' +'ALTER' +'AND' +'ANY' +'ANTI' +'ARRAY' +'AS' +'ASC' +'AT' +'AGGREGATE' +'AUTHORIZATION' +'BERNOULLI' +'BETWEEN' +'BLOCK_SIZE' +'PARTITIONED' +'PREPARE_FN' +'EXTERNAL' +'CLOSEFN' +'SORT' +'PURGE' +'STORED' +'LOCATION' +'TBLPROPERTIES' +'BY' +'CASCADE' +'CASE' +'CAST' +'CACHED' +'CHANGE' +'COLUMN' +'COLUMNS' +'COMMENT' +'COMPRESSION' +'COMPUTE' +'CREATE' +'CROSS' +'CURRENT' +'CURRENT_DATE' +'CURRENT_PATH' +'CURRENT_TIME' +'CURRENT_TIMESTAMP' +'CURRENT_USER' +'DATA' +'DATABASE' +'DATABASES' +'DAY' +'DAYS' +'DELETE' +'DEFAULT' +'DELIMITED' +'DISABLE' +'UPDATE' +'DESC' +'DESCRIBE' +'DISTINCT' +'DROP' +'ELSE' +'ENCODING' +'END' +'ESCAPE' +'ESCAPED' +'EXCEPT' +'EXCLUDING' +'EXISTS' +'EXPLAIN' +'EXTRACT' +'EXTENDED' +'FALSE' +'FIELDS' +'FILEFORMAT' +'FILES' +'FILTER' +'FIRST' +'FINALIZE_FN' +'FOLLOWING' +'FOR' +'FORMAT' +'FORMATTED' +'FOREIGN' +'FROM' +'FULL' +'FUNCTION' +'FUNCTIONS' +'GRANT' +'GROUP' +'GROUPING' +'HASH' +'HAVING' +'HOUR' +'HOURS' +'IF' +'IN' +'INCLUDING' +'INCREMENTAL' +'INNER' +'INPATH' +'INSERT' +'INTERSECT' +'INTERVAL' +'INTERMEDIATE' +'INTO' +'INIT_FN' +'INVALIDATE' +'IS' +'JOIN' +'KEY' +'KUDU' +'LAST' +'LATERAL' +'LEFT' +'LIKE' +'LIMIT' +'LINES' +'LOAD' +'LOCALTIME' +'LOCALTIMESTAMP' +'METADATA' +'MAP' +'MINUTE' +'MINUTES' +'MONTH' +'MONTHS' +'MERGE_FN' +'NFC' +'NFD' +'NFKC' +'NFKD' +'NORMALIZE' +'NOT' +'NULL' +'NULLS' +'OFFSET' +'ON' +'OPTION' +'OR' +'ORDER' +'ORDINALITY' +'OUTER' +'OWNER' +'OVER' +'OVERWRITE' +'PARTITION' +'PARTITIONS' +'PARQUET' +'POSITION' +'PRECEDING' +'PRIMARY' +'REPLICATION' +'PRIVILEGES' +'PROPERTIES' +'RANGE' +'RECOVER' +'RENAME' +'REPEATABLE' +'REPLACE' +'RESTRICT' +'RETURNS' +'REVOKE' +'REFRESH' +'REGEXP' +'RLIKE' +'RIGHT' +'ROLE' +'ROLES' +'ROW' +'ROWS' +'SCHEMA' +'SCHEMAS' +'SECOND' +'SECONDS' +'SELECT' +'SERDEPROPERTIES' +'SET' +'SEMI' +'SERVER' +'SHOW' +'SHUTDOWN' +'SOME' +'STATS' +'STRUCT' +'STRAIGHT_JOIN' +'SUBSTRING' +'SYSTEM' +'SYMBOL' +'SERIALIZE_FN' +'TABLE' +'TABLES' +'TABLESAMPLE' +'TERMINATED ' +'THEN' +'TO' +'TRUE' +'TRY_CAST' +'TRUNCATE' +'UNCACHED' +'UESCAPE' +'UNBOUNDED' +'UNION' +'UNNEST' +'UNSET' +'USE' +'USER' +'USING' +'UPDATE_FN' +'UPSERT' +'URI' +'VALUE' +'VALUES' +'VIEW' +'VIEWS' +'WHEN' +'WHERE' +'WITH' +'YEAR' +'YEARS' +'TEXTFILE' +'ORC' +'AVRO' +'SEQUENCEFILE' +'RCFILE' +'REFERENCES' +'NOVALIDATE' +'RELY' +'\'NUMDVS\'' +'\'NUMNULLS\'' +'\'AVGSIZE\'' +'\'MAXSIZE\'' +'=' +null +'<' +'<=' +'>' +'>=' +'+' +'-' +'*' +'/' +'%' +'||' +'.' +';' +',' +':' +'(' +')' +'[' +']' +'{' +'}' +'|' +'?' +'->' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +KW_ADD +KW_ALL +KW_ANALYTIC +KW_ALTER +KW_AND +KW_ANY +KW_ANTI +KW_ARRAY +KW_AS +KW_ASC +KW_AT +KW_AGGREGATE +KW_AUTHORIZATION +KW_BERNOULLI +KW_BETWEEN +KW_BLOCK_SIZE +KW_PARTITIONED +KW_PREPARE_FN +KW_EXTERNAL +KW_CLOSEFN +KW_SORT +KW_PURGE +KW_STORED +KW_LOCATION +KW_TBLPROPERTIES +KW_BY +KW_CASCADE +KW_CASE +KW_CAST +KW_CACHED +KW_CHANGE +KW_COLUMN +KW_COLUMNS +KW_COMMENT +KW_COMPRESSION +KW_COMPUTE +KW_CREATE +KW_CROSS +KW_CURRENT +KW_CURRENT_DATE +KW_CURRENT_PATH +KW_CURRENT_TIME +KW_CURRENT_TIMESTAMP +KW_CURRENT_USER +KW_DATA +KW_DATABASE +KW_DATABASES +KW_DAY +KW_DAYS +KW_DELETE +KW_DEFAULT +KW_DELIMITED +KW_DISABLE +KW_UPDATE +KW_DESC +KW_DESCRIBE +KW_DISTINCT +KW_DROP +KW_ELSE +KW_ENCODING +KW_END +KW_ESCAPE +KW_ESCAPED +KW_EXCEPT +KW_EXCLUDING +KW_EXISTS +KW_EXPLAIN +KW_EXTRACT +KW_EXTENDED +KW_FALSE +KW_FIELDS +KW_FILEFORMAT +KW_FILES +KW_FILTER +KW_FIRST +KW_FINALIZE_FN +KW_FOLLOWING +KW_FOR +KW_FORMAT +KW_FORMATTED +KW_FOREIGN +KW_FROM +KW_FULL +KW_FUNCTION +KW_FUNCTIONS +KW_GRANT +KW_GROUP +KW_GROUPING +KW_HASH +KW_HAVING +KW_HOUR +KW_HOURS +KW_IF +KW_IN +KW_INCLUDING +KW_INCREMENTAL +KW_INNER +KW_INPATH +KW_INSERT +KW_INTERSECT +KW_INTERVAL +KW_INTERMEDIATE +KW_INTO +KW_INIT_FN +KW_INVALIDATE +KW_IS +KW_JOIN +KW_KEY +KW_KUDU +KW_LAST +KW_LATERAL +KW_LEFT +KW_LIKE +KW_LIMIT +KW_LINES +KW_LOAD +KW_LOCALTIME +KW_LOCALTIMESTAMP +KW_METADATA +KW_MAP +KW_MINUTE +KW_MINUTES +KW_MONTH +KW_MONTHS +KW_MERGE_FN +KW_NFC +KW_NFD +KW_NFKC +KW_NFKD +KW_NORMALIZE +KW_NOT +KW_NULL +KW_NULLS +KW_OFFSET +KW_ON +KW_OPTION +KW_OR +KW_ORDER +KW_ORDINALITY +KW_OUTER +KW_OWNER +KW_OVER +KW_OVERWRITE +KW_PARTITION +KW_PARTITIONS +KW_PARQUET +KW_POSITION +KW_PRECEDING +KW_PRIMARY +KW_REPLICATION +KW_PRIVILEGES +KW_PROPERTIES +KW_RANGE +KW_RECOVER +KW_RENAME +KW_REPEATABLE +KW_REPLACE +KW_RESTRICT +KW_RETURNS +KW_REVOKE +KW_REFRESH +KW_REGEXP +KW_RLIKE +KW_RIGHT +KW_ROLE +KW_ROLES +KW_ROW +KW_ROWS +KW_SCHEMA +KW_SCHEMAS +KW_SECOND +KW_SECONDS +KW_SELECT +KW_SERDEPROPERTIES +KW_SET +KW_SEMI +KW_SERVER +KW_SHOW +KW_SHUTDOWN +KW_SOME +KW_STATS +KW_STRUCT +KW_STRAIGHT_JOIN +KW_SUBSTRING +KW_SYSTEM +KW_SYMBOL +KW_SERIALIZE_FN +KW_TABLE +KW_TABLES +KW_TABLESAMPLE +KW_TERMINATED +KW_THEN +KW_TO +KW_TRUE +KW_TRY_CAST +KW_TRUNCATE +KW_UNCACHED +KW_UESCAPE +KW_UNBOUNDED +KW_UNION +KW_UNNEST +KW_UNSET +KW_USE +KW_USER +KW_USING +KW_UPDATE_FN +KW_UPSERT +KW_URI +KW_VALUE +KW_VALUES +KW_VIEW +KW_VIEWS +KW_WHEN +KW_WHERE +KW_WITH +KW_YEAR +KW_YEARS +KW_TEXTFILE +KW_ORC +KW_AVRO +KW_SEQUENCEFILE +KW_RCFILE +KW_REFERENCES +KW_NOVALIDATE +KW_RELY +STATS_NUMDVS +STATS_NUMNULLS +STATS_AVGSIZE +STATS_MAXSIZE +EQ +NEQ +LT +LTE +GT +GTE +PLUS +MINUS +ASTERISK +SLASH +PERCENT +CONCAT +DOT +SEMICOLON +COMMA +COLON +LPAREN +RPAREN +LSQUARE +RSQUARE +LCURLY +RCURLY +BITWISEOR +QUESTION +RIGHT_ARROW +STRING +UNICODE_STRING +BINARY_LITERAL +INTEGER_VALUE +DECIMAL_VALUE +DOUBLE_VALUE +IDENTIFIER +DIGIT_IDENTIFIER +QUOTED_IDENTIFIER +BACKQUOTED_IDENTIFIER +TIME_WITH_TIME_ZONE +TIMESTAMP_WITH_TIME_ZONE +DOUBLE_PRECISION +SIMPLE_COMMENT +BRACKETED_COMMENT +WS + +rule names: +program +statement +useStatement +createStatement +createTableSelect +createTableLike +createKuduTableAsSelect +createView +createSchema +createRole +createAggregateFunction +createFunction +alterStatement +alterDatabase +alterStatsKey +alterPartitionCache +changeColumnDefine +alterDropSingleColumn +alterTableOwner +replaceOrAddColumns +addSingleColumn +alterTableNonKuduOrKuduOnly +addPartitionByRangeOrValue +alterFormat +recoverPartitions +dropPartitionByRangeOrValue +alterView +renameView +alterViewOwner +renameTable +alterUnSetOrSetViewTblproperties +truncateTableStatement +describeStatement +computeStatement +computeStats +computeIncrementalStats +dropStatement +dropSchema +dropView +dropTable +dropIncrementalStats +dropFunction +dropRole +grantStatement +grantRole +grant +revokeStatement +revokeRole +revoke +insertStatement +deleteStatement +delete +deleteTableRef +updateStatement +upsertStatement +showStatement +showSchemas +showTables +showFunctions +showCreateTable +showCreateView +showTableStats +showColumnStats +showPartitions +showFiles +showRoles +showRoleGrant +showGrants +showDatabaseGrant +showTableGrant +showColumnGrant +addCommentStatement +addDatabaseComments +addTableComments +addColumnComments +explainStatement +setStatement +shutdownStatement +invalidateMetaStatement +loadDataStatement +refreshStatement +refreshMeta +refreshAuth +refreshFunction +ifExists +ifNotExists +tableNameCreate +databaseNameCreate +viewNameCreate +functionNameCreate +columnNamePathCreate +databaseNamePath +tableNamePath +viewNamePath +functionNamePath +columnNamePath +tableOrViewPath +createCommonItem +assignmentList +assignmentItem +viewColumns +queryStatement +with +constraintSpecification +foreignKeySpecification +columnDefinition +kuduTableElement +kuduColumnDefinition +columnSpecWithKudu +createColumnSpecWithKudu +kuduAttributes +kuduStorageAttr +statsKey +fileFormat +kuduPartitionClause +hashClause +rangeClause +kuduPartitionSpec +cacheSpec +rangeOperator +partitionCol +likeClause +properties +partitionedBy +sortedBy +rowFormat +property +queryNoWith +queryTerm +queryPrimary +sortItem +querySpecification +groupBy +groupingElement +groupingSet +namedQuery +setQuantifier +selectItem +relation +joinType +joinCriteria +sampledRelation +sampleType +aliasedRelation +columnAliases +createColumnAliases +relationPrimary +subQueryRelation +unnest +parenthesizedRelation +columnItem +expression +booleanExpression +predicate +valueExpression +primaryExpression +stringLiteral +comparisonOperator +comparisonQuantifier +booleanValue +interval +intervalField +normalForm +type +typeParameter +baseType +whenClause +filter +over +windowFrame +frameBound +pathElement +pathSpecification +privilege +objectType +qualifiedName +principal +identifier +number +nonReserved + + +atn: +[3, 51485, 51898, 1421, 44986, 20307, 1543, 60043, 49729, 3, 272, 2764, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142, 4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147, 9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151, 4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156, 9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160, 4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165, 9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 4, 168, 9, 168, 4, 169, 9, 169, 4, 170, 9, 170, 4, 171, 9, 171, 4, 172, 9, 172, 4, 173, 9, 173, 4, 174, 9, 174, 4, 175, 9, 175, 4, 176, 9, 176, 4, 177, 9, 177, 4, 178, 9, 178, 4, 179, 9, 179, 4, 180, 9, 180, 4, 181, 9, 181, 3, 2, 3, 2, 5, 2, 365, 10, 2, 7, 2, 367, 10, 2, 12, 2, 14, 2, 370, 11, 2, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 396, 10, 3, 3, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 409, 10, 5, 3, 6, 3, 6, 5, 6, 413, 10, 6, 3, 6, 3, 6, 5, 6, 417, 10, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 7, 6, 424, 10, 6, 12, 6, 14, 6, 427, 11, 6, 3, 6, 3, 6, 5, 6, 431, 10, 6, 3, 6, 3, 6, 5, 6, 435, 10, 6, 3, 6, 3, 6, 3, 6, 3, 6, 5, 6, 441, 10, 6, 5, 6, 443, 10, 6, 3, 6, 3, 6, 3, 6, 5, 6, 448, 10, 6, 3, 7, 3, 7, 5, 7, 452, 10, 7, 3, 7, 3, 7, 5, 7, 456, 10, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 463, 10, 7, 3, 7, 3, 7, 3, 7, 5, 7, 468, 10, 7, 3, 7, 3, 7, 3, 8, 3, 8, 5, 8, 474, 10, 8, 3, 8, 3, 8, 5, 8, 478, 10, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 7, 8, 485, 10, 8, 12, 8, 14, 8, 488, 11, 8, 3, 8, 3, 8, 3, 8, 3, 8, 5, 8, 494, 10, 8, 3, 8, 3, 8, 5, 8, 498, 10, 8, 3, 8, 3, 8, 3, 8, 5, 8, 503, 10, 8, 5, 8, 505, 10, 8, 3, 8, 3, 8, 3, 8, 5, 8, 510, 10, 8, 3, 8, 3, 8, 5, 8, 514, 10, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 5, 8, 521, 10, 8, 3, 8, 3, 8, 5, 8, 525, 10, 8, 3, 9, 3, 9, 3, 9, 5, 9, 530, 10, 9, 3, 9, 3, 9, 5, 9, 534, 10, 9, 3, 9, 3, 9, 5, 9, 538, 10, 9, 3, 9, 3, 9, 5, 9, 542, 10, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 5, 10, 550, 10, 10, 3, 10, 3, 10, 3, 10, 5, 10, 555, 10, 10, 3, 10, 3, 10, 5, 10, 559, 10, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 5, 12, 567, 10, 12, 3, 12, 3, 12, 5, 12, 571, 10, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 7, 12, 578, 10, 12, 12, 12, 14, 12, 581, 11, 12, 5, 12, 583, 10, 12, 3, 12, 5, 12, 586, 10, 12, 3, 12, 3, 12, 3, 12, 3, 12, 5, 12, 592, 10, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 5, 12, 599, 10, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 5, 12, 610, 10, 12, 3, 12, 3, 12, 3, 12, 5, 12, 615, 10, 12, 3, 12, 3, 12, 3, 12, 5, 12, 620, 10, 12, 3, 12, 3, 12, 3, 12, 5, 12, 625, 10, 12, 3, 13, 3, 13, 3, 13, 5, 13, 630, 10, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 7, 13, 637, 10, 13, 12, 13, 14, 13, 640, 11, 13, 5, 13, 642, 10, 13, 3, 13, 5, 13, 645, 10, 13, 3, 13, 3, 13, 5, 13, 649, 10, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 5, 14, 675, 10, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 701, 10, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 710, 10, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 720, 10, 17, 3, 17, 5, 17, 723, 10, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 5, 19, 737, 10, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 755, 10, 21, 5, 21, 757, 10, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 7, 21, 764, 10, 21, 12, 21, 14, 21, 767, 11, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 5, 22, 777, 10, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 5, 23, 786, 10, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 5, 23, 793, 10, 23, 3, 23, 3, 23, 5, 23, 797, 10, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 5, 24, 804, 10, 24, 3, 24, 3, 24, 3, 24, 3, 24, 5, 24, 810, 10, 24, 3, 24, 5, 24, 813, 10, 24, 3, 24, 3, 24, 3, 24, 5, 24, 818, 10, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 5, 25, 825, 10, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 5, 25, 839, 10, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 5, 27, 852, 10, 27, 3, 27, 3, 27, 3, 27, 5, 27, 857, 10, 27, 3, 27, 3, 27, 3, 27, 5, 27, 862, 10, 27, 3, 28, 3, 28, 3, 28, 3, 28, 5, 28, 868, 10, 28, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 33, 3, 33, 5, 33, 904, 10, 33, 3, 33, 5, 33, 907, 10, 33, 3, 33, 3, 33, 3, 34, 3, 34, 5, 34, 913, 10, 34, 3, 34, 5, 34, 916, 10, 34, 3, 34, 3, 34, 3, 35, 3, 35, 5, 35, 922, 10, 35, 3, 36, 3, 36, 3, 36, 3, 36, 5, 36, 928, 10, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 5, 36, 940, 10, 36, 5, 36, 942, 10, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 5, 37, 950, 10, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 5, 38, 958, 10, 38, 3, 39, 3, 39, 3, 39, 5, 39, 963, 10, 39, 3, 39, 3, 39, 5, 39, 967, 10, 39, 3, 40, 3, 40, 3, 40, 5, 40, 972, 10, 40, 3, 40, 3, 40, 3, 41, 3, 41, 3, 41, 5, 41, 979, 10, 41, 3, 41, 3, 41, 5, 41, 983, 10, 41, 3, 42, 3, 42, 5, 42, 987, 10, 42, 3, 42, 3, 42, 3, 42, 3, 42, 5, 42, 993, 10, 42, 3, 43, 3, 43, 5, 43, 997, 10, 43, 3, 43, 3, 43, 5, 43, 1001, 10, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 7, 43, 1008, 10, 43, 12, 43, 14, 43, 1011, 11, 43, 5, 43, 1013, 10, 43, 3, 43, 5, 43, 1016, 10, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 45, 3, 45, 5, 45, 1024, 10, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 1038, 10, 47, 3, 47, 3, 47, 3, 47, 3, 48, 3, 48, 5, 48, 1045, 10, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 1058, 10, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 1064, 10, 50, 3, 50, 3, 50, 3, 50, 5, 50, 1069, 10, 50, 3, 50, 5, 50, 1072, 10, 50, 3, 51, 5, 51, 1075, 10, 51, 3, 51, 3, 51, 3, 51, 5, 51, 1080, 10, 51, 3, 51, 3, 51, 5, 51, 1084, 10, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 7, 51, 1091, 10, 51, 12, 51, 14, 51, 1094, 11, 51, 3, 51, 3, 51, 5, 51, 1098, 10, 51, 3, 51, 3, 51, 3, 52, 3, 52, 5, 52, 1104, 10, 52, 3, 53, 3, 53, 5, 53, 1108, 10, 53, 3, 53, 3, 53, 3, 53, 5, 53, 1113, 10, 53, 3, 54, 3, 54, 3, 54, 5, 54, 1118, 10, 54, 3, 54, 5, 54, 1121, 10, 54, 3, 54, 3, 54, 3, 54, 3, 54, 7, 54, 1127, 10, 54, 12, 54, 14, 54, 1130, 11, 54, 5, 54, 1132, 10, 54, 3, 54, 3, 54, 5, 54, 1136, 10, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 7, 55, 1146, 10, 55, 12, 55, 14, 55, 1149, 11, 55, 5, 55, 1151, 10, 55, 3, 55, 3, 55, 5, 55, 1155, 10, 55, 3, 56, 3, 56, 3, 56, 5, 56, 1160, 10, 56, 3, 56, 3, 56, 5, 56, 1164, 10, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 5, 57, 1180, 10, 57, 3, 58, 3, 58, 3, 58, 5, 58, 1185, 10, 58, 3, 58, 3, 58, 3, 58, 7, 58, 1190, 10, 58, 12, 58, 14, 58, 1193, 11, 58, 5, 58, 1195, 10, 58, 3, 59, 3, 59, 3, 59, 3, 59, 5, 59, 1201, 10, 59, 3, 59, 5, 59, 1204, 10, 59, 3, 59, 3, 59, 3, 59, 7, 59, 1209, 10, 59, 12, 59, 14, 59, 1212, 11, 59, 5, 59, 1214, 10, 59, 3, 60, 3, 60, 5, 60, 1218, 10, 60, 3, 60, 3, 60, 3, 60, 5, 60, 1223, 10, 60, 3, 60, 5, 60, 1226, 10, 60, 3, 60, 3, 60, 3, 60, 7, 60, 1231, 10, 60, 12, 60, 14, 60, 1234, 11, 60, 5, 60, 1236, 10, 60, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 65, 3, 65, 5, 65, 1260, 10, 65, 3, 65, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 5, 66, 1274, 10, 66, 3, 66, 3, 66, 5, 66, 1278, 10, 66, 3, 67, 3, 67, 5, 67, 1282, 10, 67, 3, 67, 3, 67, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 5, 69, 1302, 10, 69, 5, 69, 1304, 10, 69, 5, 69, 1306, 10, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 1315, 10, 70, 5, 70, 1317, 10, 70, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 5, 71, 1326, 10, 71, 5, 71, 1328, 10, 71, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 5, 72, 1337, 10, 72, 5, 72, 1339, 10, 72, 3, 73, 3, 73, 3, 73, 5, 73, 1344, 10, 73, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 5, 74, 1353, 10, 74, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 5, 75, 1362, 10, 75, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 5, 76, 1371, 10, 76, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 5, 78, 1382, 10, 78, 3, 79, 3, 79, 3, 79, 3, 79, 5, 79, 1388, 10, 79, 3, 79, 3, 79, 3, 79, 5, 79, 1393, 10, 79, 3, 79, 5, 79, 1396, 10, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 5, 81, 1409, 10, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 5, 81, 1419, 10, 81, 3, 81, 3, 81, 5, 81, 1423, 10, 81, 3, 82, 3, 82, 3, 82, 5, 82, 1428, 10, 82, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 7, 83, 1437, 10, 83, 12, 83, 14, 83, 1440, 11, 83, 3, 83, 3, 83, 5, 83, 1444, 10, 83, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 87, 3, 87, 3, 87, 3, 87, 3, 88, 3, 88, 3, 89, 3, 89, 3, 90, 3, 90, 3, 91, 3, 91, 3, 92, 3, 92, 3, 93, 3, 93, 3, 94, 3, 94, 3, 94, 7, 94, 1475, 10, 94, 12, 94, 14, 94, 1478, 11, 94, 3, 95, 3, 95, 3, 95, 7, 95, 1483, 10, 95, 12, 95, 14, 95, 1486, 11, 95, 3, 96, 3, 96, 3, 97, 3, 97, 3, 98, 3, 98, 5, 98, 1494, 10, 98, 3, 99, 3, 99, 3, 99, 5, 99, 1499, 10, 99, 3, 99, 3, 99, 5, 99, 1503, 10, 99, 3, 99, 3, 99, 3, 99, 5, 99, 1508, 10, 99, 3, 99, 3, 99, 3, 99, 5, 99, 1513, 10, 99, 3, 99, 3, 99, 3, 99, 5, 99, 1518, 10, 99, 3, 99, 3, 99, 5, 99, 1522, 10, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 5, 99, 1531, 10, 99, 3, 99, 5, 99, 1534, 10, 99, 3, 99, 3, 99, 5, 99, 1538, 10, 99, 3, 100, 3, 100, 3, 100, 7, 100, 1543, 10, 100, 12, 100, 14, 100, 1546, 11, 100, 3, 101, 3, 101, 3, 101, 3, 101, 3, 102, 3, 102, 3, 102, 3, 102, 5, 102, 1556, 10, 102, 3, 102, 3, 102, 3, 102, 3, 102, 5, 102, 1562, 10, 102, 7, 102, 1564, 10, 102, 12, 102, 14, 102, 1567, 11, 102, 3, 102, 3, 102, 3, 103, 5, 103, 1572, 10, 103, 3, 103, 3, 103, 3, 104, 3, 104, 3, 104, 3, 104, 7, 104, 1580, 10, 104, 12, 104, 14, 104, 1583, 11, 104, 3, 105, 3, 105, 3, 105, 3, 105, 5, 105, 1589, 10, 105, 3, 105, 3, 105, 3, 105, 5, 105, 1594, 10, 105, 3, 105, 3, 105, 3, 105, 5, 105, 1599, 10, 105, 3, 105, 3, 105, 3, 105, 5, 105, 1604, 10, 105, 3, 105, 3, 105, 7, 105, 1608, 10, 105, 12, 105, 14, 105, 1611, 11, 105, 5, 105, 1613, 10, 105, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 5, 106, 1622, 10, 106, 3, 106, 5, 106, 1625, 10, 106, 3, 106, 5, 106, 1628, 10, 106, 3, 107, 3, 107, 3, 107, 3, 107, 5, 107, 1634, 10, 107, 3, 108, 3, 108, 3, 109, 3, 109, 3, 109, 3, 109, 7, 109, 1642, 10, 109, 12, 109, 14, 109, 1645, 11, 109, 5, 109, 1647, 10, 109, 3, 109, 3, 109, 5, 109, 1651, 10, 109, 3, 109, 3, 109, 5, 109, 1655, 10, 109, 3, 110, 3, 110, 3, 110, 3, 110, 5, 110, 1661, 10, 110, 3, 110, 3, 110, 7, 110, 1665, 10, 110, 12, 110, 14, 110, 1668, 11, 110, 5, 110, 1670, 10, 110, 3, 111, 3, 111, 3, 111, 3, 111, 5, 111, 1676, 10, 111, 3, 111, 3, 111, 7, 111, 1680, 10, 111, 12, 111, 14, 111, 1683, 11, 111, 5, 111, 1685, 10, 111, 3, 112, 5, 112, 1688, 10, 112, 3, 112, 3, 112, 5, 112, 1692, 10, 112, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 5, 113, 1702, 10, 113, 3, 114, 3, 114, 3, 115, 3, 115, 3, 116, 3, 116, 3, 116, 7, 116, 1711, 10, 116, 12, 116, 14, 116, 1714, 11, 116, 3, 116, 3, 116, 5, 116, 1718, 10, 116, 3, 116, 5, 116, 1721, 10, 116, 3, 117, 3, 117, 5, 117, 1725, 10, 117, 3, 117, 3, 117, 3, 117, 3, 118, 3, 118, 5, 118, 1732, 10, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 7, 118, 1740, 10, 118, 12, 118, 14, 118, 1743, 11, 118, 3, 118, 3, 118, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 5, 119, 1754, 10, 119, 3, 119, 3, 119, 3, 119, 3, 119, 5, 119, 1760, 10, 119, 5, 119, 1762, 10, 119, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 5, 120, 1771, 10, 120, 3, 120, 5, 120, 1774, 10, 120, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 5, 121, 1781, 10, 121, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 5, 122, 1791, 10, 122, 3, 123, 3, 123, 3, 123, 3, 123, 5, 123, 1797, 10, 123, 3, 124, 3, 124, 3, 124, 3, 124, 7, 124, 1803, 10, 124, 12, 124, 14, 124, 1806, 11, 124, 3, 124, 3, 124, 3, 125, 3, 125, 3, 125, 3, 125, 7, 125, 1814, 10, 125, 12, 125, 14, 125, 1817, 11, 125, 3, 125, 3, 125, 3, 126, 3, 126, 3, 126, 7, 126, 1824, 10, 126, 12, 126, 14, 126, 1827, 11, 126, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 5, 127, 1837, 10, 127, 5, 127, 1839, 10, 127, 3, 127, 3, 127, 3, 127, 3, 127, 5, 127, 1845, 10, 127, 3, 128, 3, 128, 3, 128, 5, 128, 1850, 10, 128, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 7, 129, 1858, 10, 129, 12, 129, 14, 129, 1861, 11, 129, 5, 129, 1863, 10, 129, 3, 129, 3, 129, 3, 129, 3, 129, 5, 129, 1869, 10, 129, 5, 129, 1871, 10, 129, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 5, 130, 1879, 10, 130, 3, 130, 3, 130, 3, 130, 3, 130, 5, 130, 1885, 10, 130, 3, 130, 7, 130, 1888, 10, 130, 12, 130, 14, 130, 1891, 11, 130, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 7, 131, 1900, 10, 131, 12, 131, 14, 131, 1903, 11, 131, 3, 131, 3, 131, 3, 131, 3, 131, 5, 131, 1909, 10, 131, 3, 132, 3, 132, 5, 132, 1913, 10, 132, 3, 132, 3, 132, 5, 132, 1917, 10, 132, 3, 133, 3, 133, 5, 133, 1921, 10, 133, 3, 133, 5, 133, 1924, 10, 133, 3, 133, 3, 133, 3, 133, 7, 133, 1929, 10, 133, 12, 133, 14, 133, 1932, 11, 133, 3, 133, 3, 133, 3, 133, 3, 133, 7, 133, 1938, 10, 133, 12, 133, 14, 133, 1941, 11, 133, 5, 133, 1943, 10, 133, 3, 133, 3, 133, 5, 133, 1947, 10, 133, 3, 133, 3, 133, 3, 133, 5, 133, 1952, 10, 133, 3, 133, 3, 133, 5, 133, 1956, 10, 133, 3, 134, 5, 134, 1959, 10, 134, 3, 134, 3, 134, 3, 134, 7, 134, 1964, 10, 134, 12, 134, 14, 134, 1967, 11, 134, 3, 135, 3, 135, 3, 136, 3, 136, 3, 136, 3, 136, 7, 136, 1975, 10, 136, 12, 136, 14, 136, 1978, 11, 136, 5, 136, 1980, 10, 136, 3, 136, 3, 136, 5, 136, 1984, 10, 136, 3, 137, 3, 137, 5, 137, 1988, 10, 137, 3, 137, 3, 137, 3, 137, 3, 138, 3, 138, 3, 139, 3, 139, 5, 139, 1997, 10, 139, 3, 139, 5, 139, 2000, 10, 139, 3, 139, 3, 139, 3, 139, 3, 139, 3, 139, 5, 139, 2007, 10, 139, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 5, 140, 2021, 10, 140, 7, 140, 2023, 10, 140, 12, 140, 14, 140, 2026, 11, 140, 3, 141, 5, 141, 2029, 10, 141, 3, 141, 3, 141, 5, 141, 2033, 10, 141, 3, 141, 3, 141, 5, 141, 2037, 10, 141, 3, 141, 3, 141, 5, 141, 2041, 10, 141, 3, 141, 3, 141, 5, 141, 2045, 10, 141, 3, 141, 3, 141, 5, 141, 2049, 10, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 5, 141, 2059, 10, 141, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 7, 142, 2068, 10, 142, 12, 142, 14, 142, 2071, 11, 142, 3, 142, 3, 142, 5, 142, 2075, 10, 142, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 5, 143, 2088, 10, 143, 5, 143, 2090, 10, 143, 3, 144, 3, 144, 3, 145, 3, 145, 5, 145, 2096, 10, 145, 3, 145, 3, 145, 5, 145, 2100, 10, 145, 5, 145, 2102, 10, 145, 3, 146, 3, 146, 3, 146, 3, 146, 7, 146, 2108, 10, 146, 12, 146, 14, 146, 2111, 11, 146, 3, 146, 3, 146, 3, 147, 3, 147, 3, 147, 3, 147, 7, 147, 2119, 10, 147, 12, 147, 14, 147, 2122, 11, 147, 3, 147, 3, 147, 3, 148, 3, 148, 5, 148, 2128, 10, 148, 3, 148, 3, 148, 3, 148, 5, 148, 2133, 10, 148, 3, 149, 3, 149, 3, 149, 3, 149, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 7, 150, 2144, 10, 150, 12, 150, 14, 150, 2147, 11, 150, 3, 150, 3, 150, 3, 150, 5, 150, 2152, 10, 150, 3, 151, 3, 151, 3, 151, 3, 151, 3, 152, 3, 152, 5, 152, 2160, 10, 152, 3, 153, 3, 153, 3, 154, 3, 154, 3, 154, 5, 154, 2167, 10, 154, 3, 154, 3, 154, 5, 154, 2171, 10, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 7, 154, 2179, 10, 154, 12, 154, 14, 154, 2182, 11, 154, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 5, 155, 2192, 10, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 5, 155, 2200, 10, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 7, 155, 2207, 10, 155, 12, 155, 14, 155, 2210, 11, 155, 3, 155, 3, 155, 3, 155, 5, 155, 2215, 10, 155, 3, 155, 3, 155, 3, 155, 5, 155, 2220, 10, 155, 3, 155, 3, 155, 3, 155, 3, 155, 5, 155, 2226, 10, 155, 3, 155, 3, 155, 3, 155, 3, 155, 5, 155, 2232, 10, 155, 3, 155, 3, 155, 3, 155, 5, 155, 2237, 10, 155, 3, 155, 3, 155, 3, 155, 5, 155, 2242, 10, 155, 3, 156, 3, 156, 3, 156, 3, 156, 5, 156, 2248, 10, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 7, 156, 2259, 10, 156, 12, 156, 14, 156, 2262, 11, 156, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 5, 157, 2288, 10, 157, 3, 157, 3, 157, 3, 157, 3, 157, 5, 157, 2294, 10, 157, 7, 157, 2296, 10, 157, 12, 157, 14, 157, 2299, 11, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 7, 157, 2308, 10, 157, 12, 157, 14, 157, 2311, 11, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 5, 157, 2320, 10, 157, 3, 157, 5, 157, 2323, 10, 157, 3, 157, 3, 157, 3, 157, 5, 157, 2328, 10, 157, 3, 157, 3, 157, 3, 157, 7, 157, 2333, 10, 157, 12, 157, 14, 157, 2336, 11, 157, 5, 157, 2338, 10, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 7, 157, 2345, 10, 157, 12, 157, 14, 157, 2348, 11, 157, 5, 157, 2350, 10, 157, 3, 157, 3, 157, 5, 157, 2354, 10, 157, 3, 157, 5, 157, 2357, 10, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 7, 157, 2367, 10, 157, 12, 157, 14, 157, 2370, 11, 157, 5, 157, 2372, 10, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 6, 157, 2389, 10, 157, 13, 157, 14, 157, 2390, 3, 157, 3, 157, 5, 157, 2395, 10, 157, 3, 157, 3, 157, 3, 157, 3, 157, 6, 157, 2401, 10, 157, 13, 157, 14, 157, 2402, 3, 157, 3, 157, 5, 157, 2407, 10, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 7, 157, 2430, 10, 157, 12, 157, 14, 157, 2433, 11, 157, 5, 157, 2435, 10, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 5, 157, 2444, 10, 157, 3, 157, 3, 157, 3, 157, 3, 157, 5, 157, 2450, 10, 157, 3, 157, 3, 157, 3, 157, 3, 157, 5, 157, 2456, 10, 157, 3, 157, 3, 157, 3, 157, 3, 157, 5, 157, 2462, 10, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 5, 157, 2473, 10, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 5, 157, 2482, 10, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 7, 157, 2502, 10, 157, 12, 157, 14, 157, 2505, 11, 157, 5, 157, 2507, 10, 157, 3, 157, 5, 157, 2510, 10, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 7, 157, 2520, 10, 157, 12, 157, 14, 157, 2523, 11, 157, 3, 158, 3, 158, 3, 158, 3, 158, 5, 158, 2529, 10, 158, 5, 158, 2531, 10, 158, 3, 159, 3, 159, 3, 160, 3, 160, 3, 161, 3, 161, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 5, 162, 2553, 10, 162, 3, 163, 3, 163, 3, 164, 3, 164, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 7, 165, 2582, 10, 165, 12, 165, 14, 165, 2585, 11, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 7, 165, 2594, 10, 165, 12, 165, 14, 165, 2597, 11, 165, 3, 165, 3, 165, 5, 165, 2601, 10, 165, 5, 165, 2603, 10, 165, 3, 165, 3, 165, 7, 165, 2607, 10, 165, 12, 165, 14, 165, 2610, 11, 165, 3, 166, 3, 166, 5, 166, 2614, 10, 166, 3, 167, 3, 167, 3, 167, 3, 167, 5, 167, 2620, 10, 167, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 7, 170, 2640, 10, 170, 12, 170, 14, 170, 2643, 11, 170, 5, 170, 2645, 10, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 7, 170, 2652, 10, 170, 12, 170, 14, 170, 2655, 11, 170, 5, 170, 2657, 10, 170, 3, 170, 5, 170, 2660, 10, 170, 3, 170, 3, 170, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 5, 171, 2680, 10, 171, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 5, 172, 2691, 10, 172, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 5, 173, 2698, 10, 173, 3, 174, 3, 174, 3, 174, 7, 174, 2703, 10, 174, 12, 174, 14, 174, 2706, 11, 174, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 5, 175, 2719, 10, 175, 5, 175, 2721, 10, 175, 3, 176, 3, 176, 3, 177, 3, 177, 3, 177, 7, 177, 2728, 10, 177, 12, 177, 14, 177, 2731, 11, 177, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 5, 178, 2739, 10, 178, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 5, 179, 2746, 10, 179, 3, 180, 5, 180, 2749, 10, 180, 3, 180, 3, 180, 5, 180, 2753, 10, 180, 3, 180, 3, 180, 5, 180, 2757, 10, 180, 3, 180, 5, 180, 2760, 10, 180, 3, 181, 3, 181, 3, 181, 12, 765, 1438, 1609, 1643, 1666, 1681, 1712, 1741, 1815, 2297, 2, 8, 258, 278, 306, 310, 312, 328, 182, 2, 2, 4, 2, 6, 2, 8, 2, 10, 2, 12, 2, 14, 2, 16, 2, 18, 2, 20, 2, 22, 2, 24, 2, 26, 2, 28, 2, 30, 2, 32, 2, 34, 2, 36, 2, 38, 2, 40, 2, 42, 2, 44, 2, 46, 2, 48, 2, 50, 2, 52, 2, 54, 2, 56, 2, 58, 2, 60, 2, 62, 2, 64, 2, 66, 2, 68, 2, 70, 2, 72, 2, 74, 2, 76, 2, 78, 2, 80, 2, 82, 2, 84, 2, 86, 2, 88, 2, 90, 2, 92, 2, 94, 2, 96, 2, 98, 2, 100, 2, 102, 2, 104, 2, 106, 2, 108, 2, 110, 2, 112, 2, 114, 2, 116, 2, 118, 2, 120, 2, 122, 2, 124, 2, 126, 2, 128, 2, 130, 2, 132, 2, 134, 2, 136, 2, 138, 2, 140, 2, 142, 2, 144, 2, 146, 2, 148, 2, 150, 2, 152, 2, 154, 2, 156, 2, 158, 2, 160, 2, 162, 2, 164, 2, 166, 2, 168, 2, 170, 2, 172, 2, 174, 2, 176, 2, 178, 2, 180, 2, 182, 2, 184, 2, 186, 2, 188, 2, 190, 2, 192, 2, 194, 2, 196, 2, 198, 2, 200, 2, 202, 2, 204, 2, 206, 2, 208, 2, 210, 2, 212, 2, 214, 2, 216, 2, 218, 2, 220, 2, 222, 2, 224, 2, 226, 2, 228, 2, 230, 2, 232, 2, 234, 2, 236, 2, 238, 2, 240, 2, 242, 2, 244, 2, 246, 2, 248, 2, 250, 2, 252, 2, 254, 2, 256, 2, 258, 2, 260, 2, 262, 2, 264, 2, 266, 2, 268, 2, 270, 2, 272, 2, 274, 2, 276, 2, 278, 2, 280, 2, 282, 2, 284, 2, 286, 2, 288, 2, 290, 2, 292, 2, 294, 2, 296, 2, 298, 2, 300, 2, 302, 2, 304, 2, 306, 2, 308, 2, 310, 2, 312, 2, 314, 2, 316, 2, 318, 2, 320, 2, 322, 2, 324, 2, 326, 2, 328, 2, 330, 2, 332, 2, 334, 2, 336, 2, 338, 2, 340, 2, 342, 2, 344, 2, 346, 2, 348, 2, 350, 2, 352, 2, 354, 2, 356, 2, 358, 2, 360, 2, 2, 30, 4, 2, 48, 48, 171, 171, 4, 2, 167, 167, 206, 206, 4, 2, 177, 177, 204, 204, 4, 2, 71, 71, 82, 82, 4, 2, 29, 29, 160, 160, 4, 2, 105, 105, 145, 145, 4, 2, 49, 49, 172, 172, 4, 2, 5, 5, 14, 14, 5, 2, 89, 89, 167, 167, 206, 206, 4, 2, 179, 179, 210, 210, 3, 2, 228, 231, 4, 2, 148, 148, 220, 224, 4, 2, 67, 67, 97, 97, 4, 2, 66, 66, 202, 202, 4, 2, 12, 12, 57, 57, 4, 2, 77, 77, 112, 112, 4, 2, 4, 4, 59, 59, 4, 2, 16, 16, 187, 187, 3, 2, 238, 239, 3, 2, 240, 242, 3, 2, 232, 237, 5, 2, 4, 4, 8, 8, 182, 182, 4, 2, 72, 72, 196, 196, 7, 2, 50, 51, 93, 94, 123, 126, 173, 174, 218, 219, 3, 2, 128, 131, 4, 2, 79, 79, 150, 150, 6, 2, 48, 48, 179, 179, 190, 190, 210, 210, 49, 2, 3, 4, 8, 8, 10, 10, 12, 13, 16, 16, 29, 29, 34, 36, 41, 41, 47, 51, 53, 53, 57, 57, 67, 67, 69, 69, 76, 77, 79, 79, 81, 81, 87, 88, 93, 93, 95, 95, 97, 97, 103, 103, 112, 113, 116, 116, 122, 123, 125, 125, 128, 131, 135, 136, 138, 138, 141, 141, 144, 144, 146, 150, 153, 155, 157, 160, 162, 162, 167, 174, 177, 177, 180, 180, 182, 183, 186, 187, 191, 192, 195, 195, 197, 198, 201, 201, 205, 206, 213, 214, 218, 218, 220, 224, 2, 3087, 2, 368, 3, 2, 2, 2, 4, 395, 3, 2, 2, 2, 6, 397, 3, 2, 2, 2, 8, 408, 3, 2, 2, 2, 10, 410, 3, 2, 2, 2, 12, 449, 3, 2, 2, 2, 14, 471, 3, 2, 2, 2, 16, 526, 3, 2, 2, 2, 18, 546, 3, 2, 2, 2, 20, 560, 3, 2, 2, 2, 22, 564, 3, 2, 2, 2, 24, 626, 3, 2, 2, 2, 26, 674, 3, 2, 2, 2, 28, 676, 3, 2, 2, 2, 30, 684, 3, 2, 2, 2, 32, 704, 3, 2, 2, 2, 34, 724, 3, 2, 2, 2, 36, 731, 3, 2, 2, 2, 38, 740, 3, 2, 2, 2, 40, 748, 3, 2, 2, 2, 42, 770, 3, 2, 2, 2, 44, 780, 3, 2, 2, 2, 46, 798, 3, 2, 2, 2, 48, 819, 3, 2, 2, 2, 50, 840, 3, 2, 2, 2, 52, 846, 3, 2, 2, 2, 54, 863, 3, 2, 2, 2, 56, 872, 3, 2, 2, 2, 58, 879, 3, 2, 2, 2, 60, 887, 3, 2, 2, 2, 62, 894, 3, 2, 2, 2, 64, 901, 3, 2, 2, 2, 66, 910, 3, 2, 2, 2, 68, 921, 3, 2, 2, 2, 70, 923, 3, 2, 2, 2, 72, 943, 3, 2, 2, 2, 74, 957, 3, 2, 2, 2, 76, 959, 3, 2, 2, 2, 78, 968, 3, 2, 2, 2, 80, 975, 3, 2, 2, 2, 82, 984, 3, 2, 2, 2, 84, 994, 3, 2, 2, 2, 86, 1017, 3, 2, 2, 2, 88, 1023, 3, 2, 2, 2, 90, 1025, 3, 2, 2, 2, 92, 1032, 3, 2, 2, 2, 94, 1044, 3, 2, 2, 2, 96, 1046, 3, 2, 2, 2, 98, 1053, 3, 2, 2, 2, 100, 1074, 3, 2, 2, 2, 102, 1103, 3, 2, 2, 2, 104, 1105, 3, 2, 2, 2, 106, 1114, 3, 2, 2, 2, 108, 1137, 3, 2, 2, 2, 110, 1156, 3, 2, 2, 2, 112, 1179, 3, 2, 2, 2, 114, 1181, 3, 2, 2, 2, 116, 1196, 3, 2, 2, 2, 118, 1215, 3, 2, 2, 2, 120, 1237, 3, 2, 2, 2, 122, 1242, 3, 2, 2, 2, 124, 1247, 3, 2, 2, 2, 126, 1252, 3, 2, 2, 2, 128, 1257, 3, 2, 2, 2, 130, 1264, 3, 2, 2, 2, 132, 1279, 3, 2, 2, 2, 134, 1285, 3, 2, 2, 2, 136, 1305, 3, 2, 2, 2, 138, 1307, 3, 2, 2, 2, 140, 1318, 3, 2, 2, 2, 142, 1329, 3, 2, 2, 2, 144, 1343, 3, 2, 2, 2, 146, 1345, 3, 2, 2, 2, 148, 1354, 3, 2, 2, 2, 150, 1363, 3, 2, 2, 2, 152, 1372, 3, 2, 2, 2, 154, 1375, 3, 2, 2, 2, 156, 1383, 3, 2, 2, 2, 158, 1399, 3, 2, 2, 2, 160, 1403, 3, 2, 2, 2, 162, 1427, 3, 2, 2, 2, 164, 1429, 3, 2, 2, 2, 166, 1445, 3, 2, 2, 2, 168, 1448, 3, 2, 2, 2, 170, 1452, 3, 2, 2, 2, 172, 1455, 3, 2, 2, 2, 174, 1459, 3, 2, 2, 2, 176, 1461, 3, 2, 2, 2, 178, 1463, 3, 2, 2, 2, 180, 1465, 3, 2, 2, 2, 182, 1467, 3, 2, 2, 2, 184, 1469, 3, 2, 2, 2, 186, 1471, 3, 2, 2, 2, 188, 1479, 3, 2, 2, 2, 190, 1487, 3, 2, 2, 2, 192, 1489, 3, 2, 2, 2, 194, 1493, 3, 2, 2, 2, 196, 1498, 3, 2, 2, 2, 198, 1539, 3, 2, 2, 2, 200, 1547, 3, 2, 2, 2, 202, 1551, 3, 2, 2, 2, 204, 1571, 3, 2, 2, 2, 206, 1575, 3, 2, 2, 2, 208, 1584, 3, 2, 2, 2, 210, 1614, 3, 2, 2, 2, 212, 1629, 3, 2, 2, 2, 214, 1635, 3, 2, 2, 2, 216, 1637, 3, 2, 2, 2, 218, 1656, 3, 2, 2, 2, 220, 1671, 3, 2, 2, 2, 222, 1691, 3, 2, 2, 2, 224, 1701, 3, 2, 2, 2, 226, 1703, 3, 2, 2, 2, 228, 1705, 3, 2, 2, 2, 230, 1720, 3, 2, 2, 2, 232, 1722, 3, 2, 2, 2, 234, 1729, 3, 2, 2, 2, 236, 1761, 3, 2, 2, 2, 238, 1773, 3, 2, 2, 2, 240, 1780, 3, 2, 2, 2, 242, 1790, 3, 2, 2, 2, 244, 1792, 3, 2, 2, 2, 246, 1798, 3, 2, 2, 2, 248, 1809, 3, 2, 2, 2, 250, 1820, 3, 2, 2, 2, 252, 1828, 3, 2, 2, 2, 254, 1846, 3, 2, 2, 2, 256, 1851, 3, 2, 2, 2, 258, 1872, 3, 2, 2, 2, 260, 1908, 3, 2, 2, 2, 262, 1910, 3, 2, 2, 2, 264, 1918, 3, 2, 2, 2, 266, 1958, 3, 2, 2, 2, 268, 1968, 3, 2, 2, 2, 270, 1983, 3, 2, 2, 2, 272, 1985, 3, 2, 2, 2, 274, 1992, 3, 2, 2, 2, 276, 2006, 3, 2, 2, 2, 278, 2008, 3, 2, 2, 2, 280, 2058, 3, 2, 2, 2, 282, 2074, 3, 2, 2, 2, 284, 2076, 3, 2, 2, 2, 286, 2091, 3, 2, 2, 2, 288, 2093, 3, 2, 2, 2, 290, 2103, 3, 2, 2, 2, 292, 2114, 3, 2, 2, 2, 294, 2132, 3, 2, 2, 2, 296, 2134, 3, 2, 2, 2, 298, 2138, 3, 2, 2, 2, 300, 2153, 3, 2, 2, 2, 302, 2159, 3, 2, 2, 2, 304, 2161, 3, 2, 2, 2, 306, 2170, 3, 2, 2, 2, 308, 2241, 3, 2, 2, 2, 310, 2247, 3, 2, 2, 2, 312, 2509, 3, 2, 2, 2, 314, 2530, 3, 2, 2, 2, 316, 2532, 3, 2, 2, 2, 318, 2534, 3, 2, 2, 2, 320, 2536, 3, 2, 2, 2, 322, 2552, 3, 2, 2, 2, 324, 2554, 3, 2, 2, 2, 326, 2556, 3, 2, 2, 2, 328, 2602, 3, 2, 2, 2, 330, 2613, 3, 2, 2, 2, 332, 2619, 3, 2, 2, 2, 334, 2621, 3, 2, 2, 2, 336, 2626, 3, 2, 2, 2, 338, 2632, 3, 2, 2, 2, 340, 2679, 3, 2, 2, 2, 342, 2690, 3, 2, 2, 2, 344, 2697, 3, 2, 2, 2, 346, 2699, 3, 2, 2, 2, 348, 2720, 3, 2, 2, 2, 350, 2722, 3, 2, 2, 2, 352, 2724, 3, 2, 2, 2, 354, 2738, 3, 2, 2, 2, 356, 2745, 3, 2, 2, 2, 358, 2759, 3, 2, 2, 2, 360, 2761, 3, 2, 2, 2, 362, 364, 5, 4, 3, 2, 363, 365, 7, 245, 2, 2, 364, 363, 3, 2, 2, 2, 364, 365, 3, 2, 2, 2, 365, 367, 3, 2, 2, 2, 366, 362, 3, 2, 2, 2, 367, 370, 3, 2, 2, 2, 368, 366, 3, 2, 2, 2, 368, 369, 3, 2, 2, 2, 369, 371, 3, 2, 2, 2, 370, 368, 3, 2, 2, 2, 371, 372, 7, 2, 2, 3, 372, 3, 3, 2, 2, 2, 373, 396, 5, 204, 103, 2, 374, 396, 5, 6, 4, 2, 375, 396, 5, 8, 5, 2, 376, 396, 5, 26, 14, 2, 377, 396, 5, 64, 33, 2, 378, 396, 5, 66, 34, 2, 379, 396, 5, 68, 35, 2, 380, 396, 5, 74, 38, 2, 381, 396, 5, 88, 45, 2, 382, 396, 5, 94, 48, 2, 383, 396, 5, 100, 51, 2, 384, 396, 5, 102, 52, 2, 385, 396, 5, 108, 55, 2, 386, 396, 5, 110, 56, 2, 387, 396, 5, 112, 57, 2, 388, 396, 5, 144, 73, 2, 389, 396, 5, 152, 77, 2, 390, 396, 5, 154, 78, 2, 391, 396, 5, 156, 79, 2, 392, 396, 5, 158, 80, 2, 393, 396, 5, 160, 81, 2, 394, 396, 5, 162, 82, 2, 395, 373, 3, 2, 2, 2, 395, 374, 3, 2, 2, 2, 395, 375, 3, 2, 2, 2, 395, 376, 3, 2, 2, 2, 395, 377, 3, 2, 2, 2, 395, 378, 3, 2, 2, 2, 395, 379, 3, 2, 2, 2, 395, 380, 3, 2, 2, 2, 395, 381, 3, 2, 2, 2, 395, 382, 3, 2, 2, 2, 395, 383, 3, 2, 2, 2, 395, 384, 3, 2, 2, 2, 395, 385, 3, 2, 2, 2, 395, 386, 3, 2, 2, 2, 395, 387, 3, 2, 2, 2, 395, 388, 3, 2, 2, 2, 395, 389, 3, 2, 2, 2, 395, 390, 3, 2, 2, 2, 395, 391, 3, 2, 2, 2, 395, 392, 3, 2, 2, 2, 395, 393, 3, 2, 2, 2, 395, 394, 3, 2, 2, 2, 396, 5, 3, 2, 2, 2, 397, 398, 7, 205, 2, 2, 398, 399, 5, 184, 93, 2, 399, 7, 3, 2, 2, 2, 400, 409, 5, 18, 10, 2, 401, 409, 5, 20, 11, 2, 402, 409, 5, 22, 12, 2, 403, 409, 5, 24, 13, 2, 404, 409, 5, 16, 9, 2, 405, 409, 5, 14, 8, 2, 406, 409, 5, 12, 7, 2, 407, 409, 5, 10, 6, 2, 408, 400, 3, 2, 2, 2, 408, 401, 3, 2, 2, 2, 408, 402, 3, 2, 2, 2, 408, 403, 3, 2, 2, 2, 408, 404, 3, 2, 2, 2, 408, 405, 3, 2, 2, 2, 408, 406, 3, 2, 2, 2, 408, 407, 3, 2, 2, 2, 409, 9, 3, 2, 2, 2, 410, 412, 7, 39, 2, 2, 411, 413, 7, 21, 2, 2, 412, 411, 3, 2, 2, 2, 412, 413, 3, 2, 2, 2, 413, 414, 3, 2, 2, 2, 414, 416, 7, 190, 2, 2, 415, 417, 5, 172, 87, 2, 416, 415, 3, 2, 2, 2, 416, 417, 3, 2, 2, 2, 417, 418, 3, 2, 2, 2, 418, 434, 5, 174, 88, 2, 419, 420, 7, 248, 2, 2, 420, 425, 5, 212, 107, 2, 421, 422, 7, 246, 2, 2, 422, 424, 5, 212, 107, 2, 423, 421, 3, 2, 2, 2, 424, 427, 3, 2, 2, 2, 425, 423, 3, 2, 2, 2, 425, 426, 3, 2, 2, 2, 426, 430, 3, 2, 2, 2, 427, 425, 3, 2, 2, 2, 428, 429, 7, 246, 2, 2, 429, 431, 5, 208, 105, 2, 430, 428, 3, 2, 2, 2, 430, 431, 3, 2, 2, 2, 431, 432, 3, 2, 2, 2, 432, 433, 7, 249, 2, 2, 433, 435, 3, 2, 2, 2, 434, 419, 3, 2, 2, 2, 434, 435, 3, 2, 2, 2, 435, 442, 3, 2, 2, 2, 436, 437, 7, 19, 2, 2, 437, 440, 7, 28, 2, 2, 438, 441, 5, 248, 125, 2, 439, 441, 5, 292, 147, 2, 440, 438, 3, 2, 2, 2, 440, 439, 3, 2, 2, 2, 441, 443, 3, 2, 2, 2, 442, 436, 3, 2, 2, 2, 442, 443, 3, 2, 2, 2, 443, 444, 3, 2, 2, 2, 444, 447, 5, 196, 99, 2, 445, 446, 7, 11, 2, 2, 446, 448, 5, 204, 103, 2, 447, 445, 3, 2, 2, 2, 447, 448, 3, 2, 2, 2, 448, 11, 3, 2, 2, 2, 449, 451, 7, 39, 2, 2, 450, 452, 7, 21, 2, 2, 451, 450, 3, 2, 2, 2, 451, 452, 3, 2, 2, 2, 452, 453, 3, 2, 2, 2, 453, 455, 7, 190, 2, 2, 454, 456, 5, 172, 87, 2, 455, 454, 3, 2, 2, 2, 455, 456, 3, 2, 2, 2, 456, 457, 3, 2, 2, 2, 457, 458, 5, 174, 88, 2, 458, 462, 7, 115, 2, 2, 459, 463, 5, 186, 94, 2, 460, 461, 7, 148, 2, 2, 461, 463, 5, 314, 158, 2, 462, 459, 3, 2, 2, 2, 462, 460, 3, 2, 2, 2, 463, 467, 3, 2, 2, 2, 464, 465, 7, 19, 2, 2, 465, 466, 7, 28, 2, 2, 466, 468, 5, 248, 125, 2, 467, 464, 3, 2, 2, 2, 467, 468, 3, 2, 2, 2, 468, 469, 3, 2, 2, 2, 469, 470, 5, 196, 99, 2, 470, 13, 3, 2, 2, 2, 471, 473, 7, 39, 2, 2, 472, 474, 7, 21, 2, 2, 473, 472, 3, 2, 2, 2, 473, 474, 3, 2, 2, 2, 474, 475, 3, 2, 2, 2, 475, 477, 7, 190, 2, 2, 476, 478, 5, 172, 87, 2, 477, 476, 3, 2, 2, 2, 477, 478, 3, 2, 2, 2, 478, 479, 3, 2, 2, 2, 479, 497, 5, 174, 88, 2, 480, 481, 7, 248, 2, 2, 481, 486, 5, 214, 108, 2, 482, 483, 7, 246, 2, 2, 483, 485, 5, 214, 108, 2, 484, 482, 3, 2, 2, 2, 485, 488, 3, 2, 2, 2, 486, 484, 3, 2, 2, 2, 486, 487, 3, 2, 2, 2, 487, 493, 3, 2, 2, 2, 488, 486, 3, 2, 2, 2, 489, 490, 7, 246, 2, 2, 490, 491, 7, 151, 2, 2, 491, 492, 7, 110, 2, 2, 492, 494, 5, 290, 146, 2, 493, 489, 3, 2, 2, 2, 493, 494, 3, 2, 2, 2, 494, 495, 3, 2, 2, 2, 495, 496, 7, 249, 2, 2, 496, 498, 3, 2, 2, 2, 497, 480, 3, 2, 2, 2, 497, 498, 3, 2, 2, 2, 498, 504, 3, 2, 2, 2, 499, 500, 7, 151, 2, 2, 500, 502, 7, 110, 2, 2, 501, 503, 5, 290, 146, 2, 502, 501, 3, 2, 2, 2, 502, 503, 3, 2, 2, 2, 503, 505, 3, 2, 2, 2, 504, 499, 3, 2, 2, 2, 504, 505, 3, 2, 2, 2, 505, 509, 3, 2, 2, 2, 506, 507, 7, 146, 2, 2, 507, 508, 7, 28, 2, 2, 508, 510, 5, 230, 116, 2, 509, 506, 3, 2, 2, 2, 509, 510, 3, 2, 2, 2, 510, 513, 3, 2, 2, 2, 511, 512, 7, 36, 2, 2, 512, 514, 5, 314, 158, 2, 513, 511, 3, 2, 2, 2, 513, 514, 3, 2, 2, 2, 514, 515, 3, 2, 2, 2, 515, 516, 7, 25, 2, 2, 516, 517, 7, 11, 2, 2, 517, 520, 7, 111, 2, 2, 518, 519, 7, 27, 2, 2, 519, 521, 5, 246, 124, 2, 520, 518, 3, 2, 2, 2, 520, 521, 3, 2, 2, 2, 521, 524, 3, 2, 2, 2, 522, 523, 7, 11, 2, 2, 523, 525, 5, 204, 103, 2, 524, 522, 3, 2, 2, 2, 524, 525, 3, 2, 2, 2, 525, 15, 3, 2, 2, 2, 526, 527, 7, 39, 2, 2, 527, 529, 7, 213, 2, 2, 528, 530, 5, 172, 87, 2, 529, 528, 3, 2, 2, 2, 529, 530, 3, 2, 2, 2, 530, 531, 3, 2, 2, 2, 531, 533, 5, 178, 90, 2, 532, 534, 5, 202, 102, 2, 533, 532, 3, 2, 2, 2, 533, 534, 3, 2, 2, 2, 534, 537, 3, 2, 2, 2, 535, 536, 7, 36, 2, 2, 536, 538, 5, 314, 158, 2, 537, 535, 3, 2, 2, 2, 537, 538, 3, 2, 2, 2, 538, 541, 3, 2, 2, 2, 539, 540, 7, 27, 2, 2, 540, 542, 5, 246, 124, 2, 541, 539, 3, 2, 2, 2, 541, 542, 3, 2, 2, 2, 542, 543, 3, 2, 2, 2, 543, 544, 7, 11, 2, 2, 544, 545, 5, 204, 103, 2, 545, 17, 3, 2, 2, 2, 546, 547, 7, 39, 2, 2, 547, 549, 9, 2, 2, 2, 548, 550, 5, 172, 87, 2, 549, 548, 3, 2, 2, 2, 549, 550, 3, 2, 2, 2, 550, 551, 3, 2, 2, 2, 551, 554, 5, 176, 89, 2, 552, 553, 7, 36, 2, 2, 553, 555, 5, 314, 158, 2, 554, 552, 3, 2, 2, 2, 554, 555, 3, 2, 2, 2, 555, 558, 3, 2, 2, 2, 556, 557, 7, 26, 2, 2, 557, 559, 5, 314, 158, 2, 558, 556, 3, 2, 2, 2, 558, 559, 3, 2, 2, 2, 559, 19, 3, 2, 2, 2, 560, 561, 7, 39, 2, 2, 561, 562, 7, 167, 2, 2, 562, 563, 5, 356, 179, 2, 563, 21, 3, 2, 2, 2, 564, 566, 7, 39, 2, 2, 565, 567, 7, 14, 2, 2, 566, 565, 3, 2, 2, 2, 566, 567, 3, 2, 2, 2, 567, 568, 3, 2, 2, 2, 568, 570, 7, 86, 2, 2, 569, 571, 5, 172, 87, 2, 570, 569, 3, 2, 2, 2, 570, 571, 3, 2, 2, 2, 571, 572, 3, 2, 2, 2, 572, 585, 5, 180, 91, 2, 573, 582, 7, 248, 2, 2, 574, 579, 5, 328, 165, 2, 575, 576, 7, 246, 2, 2, 576, 578, 5, 328, 165, 2, 577, 575, 3, 2, 2, 2, 578, 581, 3, 2, 2, 2, 579, 577, 3, 2, 2, 2, 579, 580, 3, 2, 2, 2, 580, 583, 3, 2, 2, 2, 581, 579, 3, 2, 2, 2, 582, 574, 3, 2, 2, 2, 582, 583, 3, 2, 2, 2, 583, 584, 3, 2, 2, 2, 584, 586, 7, 249, 2, 2, 585, 573, 3, 2, 2, 2, 585, 586, 3, 2, 2, 2, 586, 587, 3, 2, 2, 2, 587, 588, 7, 161, 2, 2, 588, 591, 5, 328, 165, 2, 589, 590, 7, 104, 2, 2, 590, 592, 5, 328, 165, 2, 591, 589, 3, 2, 2, 2, 591, 592, 3, 2, 2, 2, 592, 593, 3, 2, 2, 2, 593, 594, 7, 26, 2, 2, 594, 598, 7, 257, 2, 2, 595, 596, 7, 106, 2, 2, 596, 597, 7, 232, 2, 2, 597, 599, 7, 257, 2, 2, 598, 595, 3, 2, 2, 2, 598, 599, 3, 2, 2, 2, 599, 600, 3, 2, 2, 2, 600, 601, 7, 208, 2, 2, 601, 602, 7, 232, 2, 2, 602, 603, 7, 257, 2, 2, 603, 604, 7, 127, 2, 2, 604, 605, 7, 232, 2, 2, 605, 609, 7, 257, 2, 2, 606, 607, 7, 20, 2, 2, 607, 608, 7, 232, 2, 2, 608, 610, 7, 257, 2, 2, 609, 606, 3, 2, 2, 2, 609, 610, 3, 2, 2, 2, 610, 614, 3, 2, 2, 2, 611, 612, 7, 22, 2, 2, 612, 613, 7, 232, 2, 2, 613, 615, 7, 257, 2, 2, 614, 611, 3, 2, 2, 2, 614, 615, 3, 2, 2, 2, 615, 619, 3, 2, 2, 2, 616, 617, 7, 189, 2, 2, 617, 618, 7, 232, 2, 2, 618, 620, 7, 257, 2, 2, 619, 616, 3, 2, 2, 2, 619, 620, 3, 2, 2, 2, 620, 624, 3, 2, 2, 2, 621, 622, 7, 78, 2, 2, 622, 623, 7, 232, 2, 2, 623, 625, 7, 257, 2, 2, 624, 621, 3, 2, 2, 2, 624, 625, 3, 2, 2, 2, 625, 23, 3, 2, 2, 2, 626, 627, 7, 39, 2, 2, 627, 629, 7, 86, 2, 2, 628, 630, 5, 172, 87, 2, 629, 628, 3, 2, 2, 2, 629, 630, 3, 2, 2, 2, 630, 631, 3, 2, 2, 2, 631, 644, 5, 180, 91, 2, 632, 641, 7, 248, 2, 2, 633, 638, 5, 328, 165, 2, 634, 635, 7, 246, 2, 2, 635, 637, 5, 328, 165, 2, 636, 634, 3, 2, 2, 2, 637, 640, 3, 2, 2, 2, 638, 636, 3, 2, 2, 2, 638, 639, 3, 2, 2, 2, 639, 642, 3, 2, 2, 2, 640, 638, 3, 2, 2, 2, 641, 633, 3, 2, 2, 2, 641, 642, 3, 2, 2, 2, 642, 643, 3, 2, 2, 2, 643, 645, 7, 249, 2, 2, 644, 632, 3, 2, 2, 2, 644, 645, 3, 2, 2, 2, 645, 648, 3, 2, 2, 2, 646, 647, 7, 161, 2, 2, 647, 649, 5, 328, 165, 2, 648, 646, 3, 2, 2, 2, 648, 649, 3, 2, 2, 2, 649, 650, 3, 2, 2, 2, 650, 651, 7, 26, 2, 2, 651, 652, 7, 257, 2, 2, 652, 653, 7, 188, 2, 2, 653, 654, 7, 232, 2, 2, 654, 655, 5, 314, 158, 2, 655, 25, 3, 2, 2, 2, 656, 675, 5, 28, 15, 2, 657, 675, 5, 62, 32, 2, 658, 675, 5, 60, 31, 2, 659, 675, 5, 58, 30, 2, 660, 675, 5, 54, 28, 2, 661, 675, 5, 56, 29, 2, 662, 675, 5, 52, 27, 2, 663, 675, 5, 48, 25, 2, 664, 675, 5, 50, 26, 2, 665, 675, 5, 46, 24, 2, 666, 675, 5, 44, 23, 2, 667, 675, 5, 42, 22, 2, 668, 675, 5, 40, 21, 2, 669, 675, 5, 34, 18, 2, 670, 675, 5, 30, 16, 2, 671, 675, 5, 32, 17, 2, 672, 675, 5, 36, 19, 2, 673, 675, 5, 38, 20, 2, 674, 656, 3, 2, 2, 2, 674, 657, 3, 2, 2, 2, 674, 658, 3, 2, 2, 2, 674, 659, 3, 2, 2, 2, 674, 660, 3, 2, 2, 2, 674, 661, 3, 2, 2, 2, 674, 662, 3, 2, 2, 2, 674, 663, 3, 2, 2, 2, 674, 664, 3, 2, 2, 2, 674, 665, 3, 2, 2, 2, 674, 666, 3, 2, 2, 2, 674, 667, 3, 2, 2, 2, 674, 668, 3, 2, 2, 2, 674, 669, 3, 2, 2, 2, 674, 670, 3, 2, 2, 2, 674, 671, 3, 2, 2, 2, 674, 672, 3, 2, 2, 2, 674, 673, 3, 2, 2, 2, 675, 27, 3, 2, 2, 2, 676, 677, 7, 6, 2, 2, 677, 678, 7, 48, 2, 2, 678, 679, 5, 184, 93, 2, 679, 680, 7, 177, 2, 2, 680, 681, 7, 143, 2, 2, 681, 682, 9, 3, 2, 2, 682, 683, 5, 356, 179, 2, 683, 29, 3, 2, 2, 2, 684, 685, 7, 6, 2, 2, 685, 686, 7, 190, 2, 2, 686, 687, 5, 186, 94, 2, 687, 688, 7, 177, 2, 2, 688, 689, 7, 34, 2, 2, 689, 690, 7, 183, 2, 2, 690, 691, 5, 192, 97, 2, 691, 692, 7, 248, 2, 2, 692, 693, 5, 226, 114, 2, 693, 694, 7, 232, 2, 2, 694, 700, 5, 314, 158, 2, 695, 696, 7, 246, 2, 2, 696, 697, 5, 226, 114, 2, 697, 698, 7, 232, 2, 2, 698, 699, 5, 314, 158, 2, 699, 701, 3, 2, 2, 2, 700, 695, 3, 2, 2, 2, 700, 701, 3, 2, 2, 2, 701, 702, 3, 2, 2, 2, 702, 703, 7, 249, 2, 2, 703, 31, 3, 2, 2, 2, 704, 705, 7, 6, 2, 2, 705, 706, 7, 190, 2, 2, 706, 709, 5, 186, 94, 2, 707, 708, 7, 146, 2, 2, 708, 710, 5, 304, 153, 2, 709, 707, 3, 2, 2, 2, 709, 710, 3, 2, 2, 2, 710, 711, 3, 2, 2, 2, 711, 722, 7, 177, 2, 2, 712, 713, 7, 32, 2, 2, 713, 714, 7, 96, 2, 2, 714, 719, 5, 314, 158, 2, 715, 716, 7, 217, 2, 2, 716, 717, 7, 152, 2, 2, 717, 718, 7, 232, 2, 2, 718, 720, 5, 358, 180, 2, 719, 715, 3, 2, 2, 2, 719, 720, 3, 2, 2, 2, 720, 723, 3, 2, 2, 2, 721, 723, 7, 199, 2, 2, 722, 712, 3, 2, 2, 2, 722, 721, 3, 2, 2, 2, 723, 33, 3, 2, 2, 2, 724, 725, 7, 6, 2, 2, 725, 726, 7, 190, 2, 2, 726, 727, 5, 186, 94, 2, 727, 728, 7, 33, 2, 2, 728, 729, 7, 34, 2, 2, 729, 730, 5, 218, 110, 2, 730, 35, 3, 2, 2, 2, 731, 732, 7, 6, 2, 2, 732, 733, 7, 190, 2, 2, 733, 734, 5, 186, 94, 2, 734, 736, 7, 60, 2, 2, 735, 737, 7, 34, 2, 2, 736, 735, 3, 2, 2, 2, 736, 737, 3, 2, 2, 2, 737, 738, 3, 2, 2, 2, 738, 739, 5, 192, 97, 2, 739, 37, 3, 2, 2, 2, 740, 741, 7, 6, 2, 2, 741, 742, 7, 190, 2, 2, 742, 743, 5, 186, 94, 2, 743, 744, 7, 177, 2, 2, 744, 745, 7, 143, 2, 2, 745, 746, 9, 3, 2, 2, 746, 747, 5, 356, 179, 2, 747, 39, 3, 2, 2, 2, 748, 749, 7, 6, 2, 2, 749, 750, 7, 190, 2, 2, 750, 756, 5, 186, 94, 2, 751, 757, 7, 159, 2, 2, 752, 754, 7, 3, 2, 2, 753, 755, 5, 172, 87, 2, 754, 753, 3, 2, 2, 2, 754, 755, 3, 2, 2, 2, 755, 757, 3, 2, 2, 2, 756, 751, 3, 2, 2, 2, 756, 752, 3, 2, 2, 2, 757, 758, 3, 2, 2, 2, 758, 759, 7, 35, 2, 2, 759, 760, 7, 248, 2, 2, 760, 765, 5, 218, 110, 2, 761, 762, 7, 246, 2, 2, 762, 764, 5, 218, 110, 2, 763, 761, 3, 2, 2, 2, 764, 767, 3, 2, 2, 2, 765, 766, 3, 2, 2, 2, 765, 763, 3, 2, 2, 2, 766, 768, 3, 2, 2, 2, 767, 765, 3, 2, 2, 2, 768, 769, 7, 249, 2, 2, 769, 41, 3, 2, 2, 2, 770, 771, 7, 6, 2, 2, 771, 772, 7, 190, 2, 2, 772, 773, 5, 186, 94, 2, 773, 774, 7, 3, 2, 2, 774, 776, 7, 34, 2, 2, 775, 777, 5, 172, 87, 2, 776, 775, 3, 2, 2, 2, 776, 777, 3, 2, 2, 2, 777, 778, 3, 2, 2, 2, 778, 779, 5, 220, 111, 2, 779, 43, 3, 2, 2, 2, 780, 781, 7, 6, 2, 2, 781, 782, 7, 190, 2, 2, 782, 783, 5, 186, 94, 2, 783, 785, 7, 6, 2, 2, 784, 786, 7, 34, 2, 2, 785, 784, 3, 2, 2, 2, 785, 786, 3, 2, 2, 2, 786, 787, 3, 2, 2, 2, 787, 796, 5, 192, 97, 2, 788, 792, 7, 177, 2, 2, 789, 793, 5, 224, 113, 2, 790, 791, 7, 36, 2, 2, 791, 793, 5, 314, 158, 2, 792, 789, 3, 2, 2, 2, 792, 790, 3, 2, 2, 2, 793, 797, 3, 2, 2, 2, 794, 795, 7, 60, 2, 2, 795, 797, 7, 53, 2, 2, 796, 788, 3, 2, 2, 2, 796, 794, 3, 2, 2, 2, 797, 45, 3, 2, 2, 2, 798, 799, 7, 6, 2, 2, 799, 800, 7, 190, 2, 2, 800, 801, 5, 186, 94, 2, 801, 803, 7, 3, 2, 2, 802, 804, 5, 172, 87, 2, 803, 802, 3, 2, 2, 2, 803, 804, 3, 2, 2, 2, 804, 817, 3, 2, 2, 2, 805, 806, 7, 146, 2, 2, 806, 809, 5, 304, 153, 2, 807, 808, 7, 26, 2, 2, 808, 810, 5, 314, 158, 2, 809, 807, 3, 2, 2, 2, 809, 810, 3, 2, 2, 2, 810, 812, 3, 2, 2, 2, 811, 813, 5, 238, 120, 2, 812, 811, 3, 2, 2, 2, 812, 813, 3, 2, 2, 2, 813, 818, 3, 2, 2, 2, 814, 815, 7, 155, 2, 2, 815, 816, 7, 146, 2, 2, 816, 818, 5, 236, 119, 2, 817, 805, 3, 2, 2, 2, 817, 814, 3, 2, 2, 2, 818, 47, 3, 2, 2, 2, 819, 820, 7, 6, 2, 2, 820, 821, 7, 190, 2, 2, 821, 824, 5, 186, 94, 2, 822, 823, 7, 146, 2, 2, 823, 825, 5, 304, 153, 2, 824, 822, 3, 2, 2, 2, 824, 825, 3, 2, 2, 2, 825, 826, 3, 2, 2, 2, 826, 838, 7, 177, 2, 2, 827, 828, 7, 74, 2, 2, 828, 839, 5, 228, 115, 2, 829, 830, 7, 169, 2, 2, 830, 831, 7, 81, 2, 2, 831, 839, 5, 252, 127, 2, 832, 833, 7, 26, 2, 2, 833, 839, 5, 314, 158, 2, 834, 835, 7, 27, 2, 2, 835, 839, 5, 246, 124, 2, 836, 837, 7, 176, 2, 2, 837, 839, 5, 246, 124, 2, 838, 827, 3, 2, 2, 2, 838, 829, 3, 2, 2, 2, 838, 832, 3, 2, 2, 2, 838, 834, 3, 2, 2, 2, 838, 836, 3, 2, 2, 2, 839, 49, 3, 2, 2, 2, 840, 841, 7, 6, 2, 2, 841, 842, 7, 190, 2, 2, 842, 843, 5, 186, 94, 2, 843, 844, 7, 156, 2, 2, 844, 845, 7, 147, 2, 2, 845, 51, 3, 2, 2, 2, 846, 847, 7, 6, 2, 2, 847, 848, 7, 190, 2, 2, 848, 849, 5, 186, 94, 2, 849, 851, 7, 60, 2, 2, 850, 852, 5, 170, 86, 2, 851, 850, 3, 2, 2, 2, 851, 852, 3, 2, 2, 2, 852, 861, 3, 2, 2, 2, 853, 854, 7, 146, 2, 2, 854, 856, 5, 304, 153, 2, 855, 857, 7, 24, 2, 2, 856, 855, 3, 2, 2, 2, 856, 857, 3, 2, 2, 2, 857, 862, 3, 2, 2, 2, 858, 859, 7, 155, 2, 2, 859, 860, 7, 146, 2, 2, 860, 862, 5, 236, 119, 2, 861, 853, 3, 2, 2, 2, 861, 858, 3, 2, 2, 2, 862, 53, 3, 2, 2, 2, 863, 864, 7, 6, 2, 2, 864, 865, 7, 213, 2, 2, 865, 867, 5, 188, 95, 2, 866, 868, 5, 202, 102, 2, 867, 866, 3, 2, 2, 2, 867, 868, 3, 2, 2, 2, 868, 869, 3, 2, 2, 2, 869, 870, 7, 11, 2, 2, 870, 871, 5, 204, 103, 2, 871, 55, 3, 2, 2, 2, 872, 873, 7, 6, 2, 2, 873, 874, 7, 213, 2, 2, 874, 875, 5, 188, 95, 2, 875, 876, 7, 157, 2, 2, 876, 877, 7, 195, 2, 2, 877, 878, 5, 188, 95, 2, 878, 57, 3, 2, 2, 2, 879, 880, 7, 6, 2, 2, 880, 881, 7, 213, 2, 2, 881, 882, 5, 188, 95, 2, 882, 883, 7, 177, 2, 2, 883, 884, 7, 143, 2, 2, 884, 885, 9, 3, 2, 2, 885, 886, 5, 352, 177, 2, 886, 59, 3, 2, 2, 2, 887, 888, 7, 6, 2, 2, 888, 889, 7, 190, 2, 2, 889, 890, 5, 186, 94, 2, 890, 891, 7, 157, 2, 2, 891, 892, 7, 195, 2, 2, 892, 893, 5, 186, 94, 2, 893, 61, 3, 2, 2, 2, 894, 895, 7, 6, 2, 2, 895, 896, 7, 213, 2, 2, 896, 897, 5, 188, 95, 2, 897, 898, 9, 4, 2, 2, 898, 899, 7, 27, 2, 2, 899, 900, 5, 246, 124, 2, 900, 63, 3, 2, 2, 2, 901, 903, 7, 198, 2, 2, 902, 904, 7, 190, 2, 2, 903, 902, 3, 2, 2, 2, 903, 904, 3, 2, 2, 2, 904, 906, 3, 2, 2, 2, 905, 907, 5, 170, 86, 2, 906, 905, 3, 2, 2, 2, 906, 907, 3, 2, 2, 2, 907, 908, 3, 2, 2, 2, 908, 909, 5, 186, 94, 2, 909, 65, 3, 2, 2, 2, 910, 912, 7, 58, 2, 2, 911, 913, 7, 48, 2, 2, 912, 911, 3, 2, 2, 2, 912, 913, 3, 2, 2, 2, 913, 915, 3, 2, 2, 2, 914, 916, 9, 5, 2, 2, 915, 914, 3, 2, 2, 2, 915, 916, 3, 2, 2, 2, 916, 917, 3, 2, 2, 2, 917, 918, 5, 352, 177, 2, 918, 67, 3, 2, 2, 2, 919, 922, 5, 70, 36, 2, 920, 922, 5, 72, 37, 2, 921, 919, 3, 2, 2, 2, 921, 920, 3, 2, 2, 2, 922, 69, 3, 2, 2, 2, 923, 924, 7, 38, 2, 2, 924, 925, 7, 183, 2, 2, 925, 927, 5, 186, 94, 2, 926, 928, 5, 290, 146, 2, 927, 926, 3, 2, 2, 2, 927, 928, 3, 2, 2, 2, 928, 941, 3, 2, 2, 2, 929, 930, 7, 192, 2, 2, 930, 931, 7, 187, 2, 2, 931, 932, 7, 248, 2, 2, 932, 933, 5, 358, 180, 2, 933, 939, 7, 249, 2, 2, 934, 935, 7, 158, 2, 2, 935, 936, 7, 248, 2, 2, 936, 937, 5, 358, 180, 2, 937, 938, 7, 249, 2, 2, 938, 940, 3, 2, 2, 2, 939, 934, 3, 2, 2, 2, 939, 940, 3, 2, 2, 2, 940, 942, 3, 2, 2, 2, 941, 929, 3, 2, 2, 2, 941, 942, 3, 2, 2, 2, 942, 71, 3, 2, 2, 2, 943, 944, 7, 38, 2, 2, 944, 945, 7, 98, 2, 2, 945, 946, 7, 183, 2, 2, 946, 949, 5, 186, 94, 2, 947, 948, 7, 146, 2, 2, 948, 950, 5, 304, 153, 2, 949, 947, 3, 2, 2, 2, 949, 950, 3, 2, 2, 2, 950, 73, 3, 2, 2, 2, 951, 958, 5, 86, 44, 2, 952, 958, 5, 84, 43, 2, 953, 958, 5, 82, 42, 2, 954, 958, 5, 78, 40, 2, 955, 958, 5, 80, 41, 2, 956, 958, 5, 76, 39, 2, 957, 951, 3, 2, 2, 2, 957, 952, 3, 2, 2, 2, 957, 953, 3, 2, 2, 2, 957, 954, 3, 2, 2, 2, 957, 955, 3, 2, 2, 2, 957, 956, 3, 2, 2, 2, 958, 75, 3, 2, 2, 2, 959, 960, 7, 60, 2, 2, 960, 962, 9, 2, 2, 2, 961, 963, 5, 170, 86, 2, 962, 961, 3, 2, 2, 2, 962, 963, 3, 2, 2, 2, 963, 964, 3, 2, 2, 2, 964, 966, 5, 184, 93, 2, 965, 967, 9, 6, 2, 2, 966, 965, 3, 2, 2, 2, 966, 967, 3, 2, 2, 2, 967, 77, 3, 2, 2, 2, 968, 969, 7, 60, 2, 2, 969, 971, 7, 213, 2, 2, 970, 972, 5, 170, 86, 2, 971, 970, 3, 2, 2, 2, 971, 972, 3, 2, 2, 2, 972, 973, 3, 2, 2, 2, 973, 974, 5, 188, 95, 2, 974, 79, 3, 2, 2, 2, 975, 976, 7, 60, 2, 2, 976, 978, 7, 190, 2, 2, 977, 979, 5, 170, 86, 2, 978, 977, 3, 2, 2, 2, 978, 979, 3, 2, 2, 2, 979, 980, 3, 2, 2, 2, 980, 982, 5, 186, 94, 2, 981, 983, 7, 24, 2, 2, 982, 981, 3, 2, 2, 2, 982, 983, 3, 2, 2, 2, 983, 81, 3, 2, 2, 2, 984, 986, 7, 60, 2, 2, 985, 987, 7, 98, 2, 2, 986, 985, 3, 2, 2, 2, 986, 987, 3, 2, 2, 2, 987, 988, 3, 2, 2, 2, 988, 989, 7, 183, 2, 2, 989, 992, 5, 186, 94, 2, 990, 991, 7, 146, 2, 2, 991, 993, 5, 304, 153, 2, 992, 990, 3, 2, 2, 2, 992, 993, 3, 2, 2, 2, 993, 83, 3, 2, 2, 2, 994, 996, 7, 60, 2, 2, 995, 997, 7, 14, 2, 2, 996, 995, 3, 2, 2, 2, 996, 997, 3, 2, 2, 2, 997, 998, 3, 2, 2, 2, 998, 1000, 7, 86, 2, 2, 999, 1001, 5, 170, 86, 2, 1000, 999, 3, 2, 2, 2, 1000, 1001, 3, 2, 2, 2, 1001, 1002, 3, 2, 2, 2, 1002, 1015, 5, 190, 96, 2, 1003, 1012, 7, 248, 2, 2, 1004, 1009, 5, 328, 165, 2, 1005, 1006, 7, 246, 2, 2, 1006, 1008, 5, 328, 165, 2, 1007, 1005, 3, 2, 2, 2, 1008, 1011, 3, 2, 2, 2, 1009, 1007, 3, 2, 2, 2, 1009, 1010, 3, 2, 2, 2, 1010, 1013, 3, 2, 2, 2, 1011, 1009, 3, 2, 2, 2, 1012, 1004, 3, 2, 2, 2, 1012, 1013, 3, 2, 2, 2, 1013, 1014, 3, 2, 2, 2, 1014, 1016, 7, 249, 2, 2, 1015, 1003, 3, 2, 2, 2, 1015, 1016, 3, 2, 2, 2, 1016, 85, 3, 2, 2, 2, 1017, 1018, 7, 60, 2, 2, 1018, 1019, 7, 167, 2, 2, 1019, 1020, 5, 356, 179, 2, 1020, 87, 3, 2, 2, 2, 1021, 1024, 5, 90, 46, 2, 1022, 1024, 5, 92, 47, 2, 1023, 1021, 3, 2, 2, 2, 1023, 1022, 3, 2, 2, 2, 1024, 89, 3, 2, 2, 2, 1025, 1026, 7, 88, 2, 2, 1026, 1027, 7, 167, 2, 2, 1027, 1028, 5, 356, 179, 2, 1028, 1029, 7, 195, 2, 2, 1029, 1030, 7, 89, 2, 2, 1030, 1031, 5, 356, 179, 2, 1031, 91, 3, 2, 2, 2, 1032, 1033, 7, 88, 2, 2, 1033, 1034, 5, 348, 175, 2, 1034, 1035, 7, 137, 2, 2, 1035, 1037, 5, 350, 176, 2, 1036, 1038, 5, 352, 177, 2, 1037, 1036, 3, 2, 2, 2, 1037, 1038, 3, 2, 2, 2, 1038, 1039, 3, 2, 2, 2, 1039, 1040, 7, 195, 2, 2, 1040, 1041, 5, 354, 178, 2, 1041, 93, 3, 2, 2, 2, 1042, 1045, 5, 96, 49, 2, 1043, 1045, 5, 98, 50, 2, 1044, 1042, 3, 2, 2, 2, 1044, 1043, 3, 2, 2, 2, 1045, 95, 3, 2, 2, 2, 1046, 1047, 7, 162, 2, 2, 1047, 1048, 7, 167, 2, 2, 1048, 1049, 5, 356, 179, 2, 1049, 1050, 7, 84, 2, 2, 1050, 1051, 7, 89, 2, 2, 1051, 1052, 5, 356, 179, 2, 1052, 97, 3, 2, 2, 2, 1053, 1057, 7, 162, 2, 2, 1054, 1055, 7, 88, 2, 2, 1055, 1056, 7, 138, 2, 2, 1056, 1058, 7, 80, 2, 2, 1057, 1054, 3, 2, 2, 2, 1057, 1058, 3, 2, 2, 2, 1058, 1059, 3, 2, 2, 2, 1059, 1060, 5, 348, 175, 2, 1060, 1061, 7, 137, 2, 2, 1061, 1063, 5, 350, 176, 2, 1062, 1064, 5, 352, 177, 2, 1063, 1062, 3, 2, 2, 2, 1063, 1064, 3, 2, 2, 2, 1064, 1065, 3, 2, 2, 2, 1065, 1071, 7, 84, 2, 2, 1066, 1072, 5, 354, 178, 2, 1067, 1069, 7, 167, 2, 2, 1068, 1067, 3, 2, 2, 2, 1068, 1069, 3, 2, 2, 2, 1069, 1070, 3, 2, 2, 2, 1070, 1072, 5, 356, 179, 2, 1071, 1066, 3, 2, 2, 2, 1071, 1068, 3, 2, 2, 2, 1072, 99, 3, 2, 2, 2, 1073, 1075, 5, 206, 104, 2, 1074, 1073, 3, 2, 2, 2, 1074, 1075, 3, 2, 2, 2, 1075, 1076, 3, 2, 2, 2, 1076, 1077, 7, 101, 2, 2, 1077, 1079, 9, 7, 2, 2, 1078, 1080, 7, 190, 2, 2, 1079, 1078, 3, 2, 2, 2, 1079, 1080, 3, 2, 2, 2, 1080, 1081, 3, 2, 2, 2, 1081, 1083, 5, 186, 94, 2, 1082, 1084, 5, 290, 146, 2, 1083, 1082, 3, 2, 2, 2, 1083, 1084, 3, 2, 2, 2, 1084, 1097, 3, 2, 2, 2, 1085, 1086, 7, 146, 2, 2, 1086, 1087, 7, 248, 2, 2, 1087, 1092, 5, 304, 153, 2, 1088, 1089, 7, 246, 2, 2, 1089, 1091, 5, 304, 153, 2, 1090, 1088, 3, 2, 2, 2, 1091, 1094, 3, 2, 2, 2, 1092, 1090, 3, 2, 2, 2, 1092, 1093, 3, 2, 2, 2, 1093, 1095, 3, 2, 2, 2, 1094, 1092, 3, 2, 2, 2, 1095, 1096, 7, 249, 2, 2, 1096, 1098, 3, 2, 2, 2, 1097, 1085, 3, 2, 2, 2, 1097, 1098, 3, 2, 2, 2, 1098, 1099, 3, 2, 2, 2, 1099, 1100, 5, 204, 103, 2, 1100, 101, 3, 2, 2, 2, 1101, 1104, 5, 104, 53, 2, 1102, 1104, 5, 106, 54, 2, 1103, 1101, 3, 2, 2, 2, 1103, 1102, 3, 2, 2, 2, 1104, 103, 3, 2, 2, 2, 1105, 1107, 7, 52, 2, 2, 1106, 1108, 7, 84, 2, 2, 1107, 1106, 3, 2, 2, 2, 1107, 1108, 3, 2, 2, 2, 1108, 1109, 3, 2, 2, 2, 1109, 1112, 5, 186, 94, 2, 1110, 1111, 7, 216, 2, 2, 1111, 1113, 5, 306, 154, 2, 1112, 1110, 3, 2, 2, 2, 1112, 1113, 3, 2, 2, 2, 1113, 105, 3, 2, 2, 2, 1114, 1115, 7, 52, 2, 2, 1115, 1120, 5, 186, 94, 2, 1116, 1118, 7, 11, 2, 2, 1117, 1116, 3, 2, 2, 2, 1117, 1118, 3, 2, 2, 2, 1118, 1119, 3, 2, 2, 2, 1119, 1121, 5, 356, 179, 2, 1120, 1117, 3, 2, 2, 2, 1120, 1121, 3, 2, 2, 2, 1121, 1122, 3, 2, 2, 2, 1122, 1131, 7, 84, 2, 2, 1123, 1128, 5, 278, 140, 2, 1124, 1125, 7, 246, 2, 2, 1125, 1127, 5, 278, 140, 2, 1126, 1124, 3, 2, 2, 2, 1127, 1130, 3, 2, 2, 2, 1128, 1126, 3, 2, 2, 2, 1128, 1129, 3, 2, 2, 2, 1129, 1132, 3, 2, 2, 2, 1130, 1128, 3, 2, 2, 2, 1131, 1123, 3, 2, 2, 2, 1131, 1132, 3, 2, 2, 2, 1132, 1135, 3, 2, 2, 2, 1133, 1134, 7, 216, 2, 2, 1134, 1136, 5, 306, 154, 2, 1135, 1133, 3, 2, 2, 2, 1135, 1136, 3, 2, 2, 2, 1136, 107, 3, 2, 2, 2, 1137, 1138, 7, 56, 2, 2, 1138, 1139, 5, 186, 94, 2, 1139, 1140, 7, 177, 2, 2, 1140, 1150, 5, 198, 100, 2, 1141, 1142, 7, 84, 2, 2, 1142, 1147, 5, 278, 140, 2, 1143, 1144, 7, 246, 2, 2, 1144, 1146, 5, 278, 140, 2, 1145, 1143, 3, 2, 2, 2, 1146, 1149, 3, 2, 2, 2, 1147, 1145, 3, 2, 2, 2, 1147, 1148, 3, 2, 2, 2, 1148, 1151, 3, 2, 2, 2, 1149, 1147, 3, 2, 2, 2, 1150, 1141, 3, 2, 2, 2, 1150, 1151, 3, 2, 2, 2, 1151, 1154, 3, 2, 2, 2, 1152, 1153, 7, 216, 2, 2, 1153, 1155, 5, 306, 154, 2, 1154, 1152, 3, 2, 2, 2, 1154, 1155, 3, 2, 2, 2, 1155, 109, 3, 2, 2, 2, 1156, 1157, 7, 209, 2, 2, 1157, 1159, 7, 105, 2, 2, 1158, 1160, 7, 190, 2, 2, 1159, 1158, 3, 2, 2, 2, 1159, 1160, 3, 2, 2, 2, 1160, 1161, 3, 2, 2, 2, 1161, 1163, 5, 186, 94, 2, 1162, 1164, 5, 290, 146, 2, 1163, 1162, 3, 2, 2, 2, 1163, 1164, 3, 2, 2, 2, 1164, 1165, 3, 2, 2, 2, 1165, 1166, 5, 204, 103, 2, 1166, 111, 3, 2, 2, 2, 1167, 1180, 5, 132, 67, 2, 1168, 1180, 5, 134, 68, 2, 1169, 1180, 5, 136, 69, 2, 1170, 1180, 5, 130, 66, 2, 1171, 1180, 5, 128, 65, 2, 1172, 1180, 5, 126, 64, 2, 1173, 1180, 5, 124, 63, 2, 1174, 1180, 5, 122, 62, 2, 1175, 1180, 5, 120, 61, 2, 1176, 1180, 5, 118, 60, 2, 1177, 1180, 5, 116, 59, 2, 1178, 1180, 5, 114, 58, 2, 1179, 1167, 3, 2, 2, 2, 1179, 1168, 3, 2, 2, 2, 1179, 1169, 3, 2, 2, 2, 1179, 1170, 3, 2, 2, 2, 1179, 1171, 3, 2, 2, 2, 1179, 1172, 3, 2, 2, 2, 1179, 1173, 3, 2, 2, 2, 1179, 1174, 3, 2, 2, 2, 1179, 1175, 3, 2, 2, 2, 1179, 1176, 3, 2, 2, 2, 1179, 1177, 3, 2, 2, 2, 1179, 1178, 3, 2, 2, 2, 1180, 113, 3, 2, 2, 2, 1181, 1182, 7, 180, 2, 2, 1182, 1194, 9, 8, 2, 2, 1183, 1185, 7, 115, 2, 2, 1184, 1183, 3, 2, 2, 2, 1184, 1185, 3, 2, 2, 2, 1185, 1186, 3, 2, 2, 2, 1186, 1191, 5, 314, 158, 2, 1187, 1188, 7, 254, 2, 2, 1188, 1190, 5, 314, 158, 2, 1189, 1187, 3, 2, 2, 2, 1190, 1193, 3, 2, 2, 2, 1191, 1189, 3, 2, 2, 2, 1191, 1192, 3, 2, 2, 2, 1192, 1195, 3, 2, 2, 2, 1193, 1191, 3, 2, 2, 2, 1194, 1184, 3, 2, 2, 2, 1194, 1195, 3, 2, 2, 2, 1195, 115, 3, 2, 2, 2, 1196, 1197, 7, 180, 2, 2, 1197, 1200, 7, 191, 2, 2, 1198, 1199, 7, 96, 2, 2, 1199, 1201, 5, 186, 94, 2, 1200, 1198, 3, 2, 2, 2, 1200, 1201, 3, 2, 2, 2, 1201, 1213, 3, 2, 2, 2, 1202, 1204, 7, 115, 2, 2, 1203, 1202, 3, 2, 2, 2, 1203, 1204, 3, 2, 2, 2, 1204, 1205, 3, 2, 2, 2, 1205, 1210, 5, 314, 158, 2, 1206, 1207, 7, 254, 2, 2, 1207, 1209, 5, 314, 158, 2, 1208, 1206, 3, 2, 2, 2, 1209, 1212, 3, 2, 2, 2, 1210, 1208, 3, 2, 2, 2, 1210, 1211, 3, 2, 2, 2, 1211, 1214, 3, 2, 2, 2, 1212, 1210, 3, 2, 2, 2, 1213, 1203, 3, 2, 2, 2, 1213, 1214, 3, 2, 2, 2, 1214, 117, 3, 2, 2, 2, 1215, 1217, 7, 180, 2, 2, 1216, 1218, 9, 9, 2, 2, 1217, 1216, 3, 2, 2, 2, 1217, 1218, 3, 2, 2, 2, 1218, 1219, 3, 2, 2, 2, 1219, 1222, 7, 87, 2, 2, 1220, 1221, 7, 96, 2, 2, 1221, 1223, 5, 184, 93, 2, 1222, 1220, 3, 2, 2, 2, 1222, 1223, 3, 2, 2, 2, 1223, 1235, 3, 2, 2, 2, 1224, 1226, 7, 115, 2, 2, 1225, 1224, 3, 2, 2, 2, 1225, 1226, 3, 2, 2, 2, 1226, 1227, 3, 2, 2, 2, 1227, 1232, 5, 314, 158, 2, 1228, 1229, 7, 254, 2, 2, 1229, 1231, 5, 314, 158, 2, 1230, 1228, 3, 2, 2, 2, 1231, 1234, 3, 2, 2, 2, 1232, 1230, 3, 2, 2, 2, 1232, 1233, 3, 2, 2, 2, 1233, 1236, 3, 2, 2, 2, 1234, 1232, 3, 2, 2, 2, 1235, 1225, 3, 2, 2, 2, 1235, 1236, 3, 2, 2, 2, 1236, 119, 3, 2, 2, 2, 1237, 1238, 7, 180, 2, 2, 1238, 1239, 7, 39, 2, 2, 1239, 1240, 7, 190, 2, 2, 1240, 1241, 5, 186, 94, 2, 1241, 121, 3, 2, 2, 2, 1242, 1243, 7, 180, 2, 2, 1243, 1244, 7, 39, 2, 2, 1244, 1245, 7, 213, 2, 2, 1245, 1246, 5, 188, 95, 2, 1246, 123, 3, 2, 2, 2, 1247, 1248, 7, 180, 2, 2, 1248, 1249, 7, 190, 2, 2, 1249, 1250, 7, 183, 2, 2, 1250, 1251, 5, 186, 94, 2, 1251, 125, 3, 2, 2, 2, 1252, 1253, 7, 180, 2, 2, 1253, 1254, 7, 34, 2, 2, 1254, 1255, 7, 183, 2, 2, 1255, 1256, 5, 186, 94, 2, 1256, 127, 3, 2, 2, 2, 1257, 1259, 7, 180, 2, 2, 1258, 1260, 7, 155, 2, 2, 1259, 1258, 3, 2, 2, 2, 1259, 1260, 3, 2, 2, 2, 1260, 1261, 3, 2, 2, 2, 1261, 1262, 7, 147, 2, 2, 1262, 1263, 5, 186, 94, 2, 1263, 129, 3, 2, 2, 2, 1264, 1265, 7, 180, 2, 2, 1265, 1266, 7, 75, 2, 2, 1266, 1267, 7, 96, 2, 2, 1267, 1277, 5, 186, 94, 2, 1268, 1269, 7, 146, 2, 2, 1269, 1270, 7, 248, 2, 2, 1270, 1273, 5, 304, 153, 2, 1271, 1272, 7, 246, 2, 2, 1272, 1274, 5, 304, 153, 2, 1273, 1271, 3, 2, 2, 2, 1273, 1274, 3, 2, 2, 2, 1274, 1275, 3, 2, 2, 2, 1275, 1276, 7, 249, 2, 2, 1276, 1278, 3, 2, 2, 2, 1277, 1268, 3, 2, 2, 2, 1277, 1278, 3, 2, 2, 2, 1278, 131, 3, 2, 2, 2, 1279, 1281, 7, 180, 2, 2, 1280, 1282, 7, 41, 2, 2, 1281, 1280, 3, 2, 2, 2, 1281, 1282, 3, 2, 2, 2, 1282, 1283, 3, 2, 2, 2, 1283, 1284, 7, 168, 2, 2, 1284, 133, 3, 2, 2, 2, 1285, 1286, 7, 180, 2, 2, 1286, 1287, 7, 167, 2, 2, 1287, 1288, 7, 88, 2, 2, 1288, 1289, 7, 89, 2, 2, 1289, 1290, 5, 356, 179, 2, 1290, 135, 3, 2, 2, 2, 1291, 1306, 5, 138, 70, 2, 1292, 1306, 5, 140, 71, 2, 1293, 1306, 5, 142, 72, 2, 1294, 1295, 7, 180, 2, 2, 1295, 1296, 7, 88, 2, 2, 1296, 1297, 9, 10, 2, 2, 1297, 1303, 5, 356, 179, 2, 1298, 1299, 7, 137, 2, 2, 1299, 1301, 9, 11, 2, 2, 1300, 1302, 5, 352, 177, 2, 1301, 1300, 3, 2, 2, 2, 1301, 1302, 3, 2, 2, 2, 1302, 1304, 3, 2, 2, 2, 1303, 1298, 3, 2, 2, 2, 1303, 1304, 3, 2, 2, 2, 1304, 1306, 3, 2, 2, 2, 1305, 1291, 3, 2, 2, 2, 1305, 1292, 3, 2, 2, 2, 1305, 1293, 3, 2, 2, 2, 1305, 1294, 3, 2, 2, 2, 1306, 137, 3, 2, 2, 2, 1307, 1308, 7, 180, 2, 2, 1308, 1309, 7, 88, 2, 2, 1309, 1310, 9, 10, 2, 2, 1310, 1316, 5, 356, 179, 2, 1311, 1312, 7, 137, 2, 2, 1312, 1314, 7, 48, 2, 2, 1313, 1315, 5, 184, 93, 2, 1314, 1313, 3, 2, 2, 2, 1314, 1315, 3, 2, 2, 2, 1315, 1317, 3, 2, 2, 2, 1316, 1311, 3, 2, 2, 2, 1316, 1317, 3, 2, 2, 2, 1317, 139, 3, 2, 2, 2, 1318, 1319, 7, 180, 2, 2, 1319, 1320, 7, 88, 2, 2, 1320, 1321, 9, 10, 2, 2, 1321, 1327, 5, 356, 179, 2, 1322, 1323, 7, 137, 2, 2, 1323, 1325, 7, 190, 2, 2, 1324, 1326, 5, 186, 94, 2, 1325, 1324, 3, 2, 2, 2, 1325, 1326, 3, 2, 2, 2, 1326, 1328, 3, 2, 2, 2, 1327, 1322, 3, 2, 2, 2, 1327, 1328, 3, 2, 2, 2, 1328, 141, 3, 2, 2, 2, 1329, 1330, 7, 180, 2, 2, 1330, 1331, 7, 88, 2, 2, 1331, 1332, 9, 10, 2, 2, 1332, 1338, 5, 356, 179, 2, 1333, 1334, 7, 137, 2, 2, 1334, 1336, 7, 34, 2, 2, 1335, 1337, 5, 192, 97, 2, 1336, 1335, 3, 2, 2, 2, 1336, 1337, 3, 2, 2, 2, 1337, 1339, 3, 2, 2, 2, 1338, 1333, 3, 2, 2, 2, 1338, 1339, 3, 2, 2, 2, 1339, 143, 3, 2, 2, 2, 1340, 1344, 5, 146, 74, 2, 1341, 1344, 5, 148, 75, 2, 1342, 1344, 5, 150, 76, 2, 1343, 1340, 3, 2, 2, 2, 1343, 1341, 3, 2, 2, 2, 1343, 1342, 3, 2, 2, 2, 1344, 145, 3, 2, 2, 2, 1345, 1346, 7, 36, 2, 2, 1346, 1347, 7, 137, 2, 2, 1347, 1348, 7, 48, 2, 2, 1348, 1349, 5, 184, 93, 2, 1349, 1352, 7, 108, 2, 2, 1350, 1353, 5, 314, 158, 2, 1351, 1353, 7, 134, 2, 2, 1352, 1350, 3, 2, 2, 2, 1352, 1351, 3, 2, 2, 2, 1353, 147, 3, 2, 2, 2, 1354, 1355, 7, 36, 2, 2, 1355, 1356, 7, 137, 2, 2, 1356, 1357, 7, 190, 2, 2, 1357, 1358, 5, 186, 94, 2, 1358, 1361, 7, 108, 2, 2, 1359, 1362, 5, 314, 158, 2, 1360, 1362, 7, 134, 2, 2, 1361, 1359, 3, 2, 2, 2, 1361, 1360, 3, 2, 2, 2, 1362, 149, 3, 2, 2, 2, 1363, 1364, 7, 36, 2, 2, 1364, 1365, 7, 137, 2, 2, 1365, 1366, 7, 34, 2, 2, 1366, 1367, 5, 192, 97, 2, 1367, 1370, 7, 108, 2, 2, 1368, 1371, 5, 314, 158, 2, 1369, 1371, 7, 134, 2, 2, 1370, 1368, 3, 2, 2, 2, 1370, 1369, 3, 2, 2, 2, 1371, 151, 3, 2, 2, 2, 1372, 1373, 7, 69, 2, 2, 1373, 1374, 5, 4, 3, 2, 1374, 153, 3, 2, 2, 2, 1375, 1381, 7, 177, 2, 2, 1376, 1382, 7, 4, 2, 2, 1377, 1378, 5, 356, 179, 2, 1378, 1379, 7, 232, 2, 2, 1379, 1380, 5, 304, 153, 2, 1380, 1382, 3, 2, 2, 2, 1381, 1376, 3, 2, 2, 2, 1381, 1377, 3, 2, 2, 2, 1381, 1382, 3, 2, 2, 2, 1382, 155, 3, 2, 2, 2, 1383, 1384, 7, 247, 2, 2, 1384, 1385, 7, 181, 2, 2, 1385, 1395, 7, 248, 2, 2, 1386, 1388, 5, 314, 158, 2, 1387, 1386, 3, 2, 2, 2, 1387, 1388, 3, 2, 2, 2, 1388, 1396, 3, 2, 2, 2, 1389, 1392, 5, 314, 158, 2, 1390, 1391, 7, 246, 2, 2, 1391, 1393, 5, 304, 153, 2, 1392, 1390, 3, 2, 2, 2, 1392, 1393, 3, 2, 2, 2, 1393, 1396, 3, 2, 2, 2, 1394, 1396, 5, 304, 153, 2, 1395, 1387, 3, 2, 2, 2, 1395, 1389, 3, 2, 2, 2, 1395, 1394, 3, 2, 2, 2, 1396, 1397, 3, 2, 2, 2, 1397, 1398, 7, 249, 2, 2, 1398, 157, 3, 2, 2, 2, 1399, 1400, 7, 107, 2, 2, 1400, 1401, 7, 121, 2, 2, 1401, 1402, 5, 186, 94, 2, 1402, 159, 3, 2, 2, 2, 1403, 1404, 7, 118, 2, 2, 1404, 1405, 7, 47, 2, 2, 1405, 1406, 7, 100, 2, 2, 1406, 1408, 7, 257, 2, 2, 1407, 1409, 7, 145, 2, 2, 1408, 1407, 3, 2, 2, 2, 1408, 1409, 3, 2, 2, 2, 1409, 1410, 3, 2, 2, 2, 1410, 1411, 7, 105, 2, 2, 1411, 1412, 7, 190, 2, 2, 1412, 1422, 5, 186, 94, 2, 1413, 1414, 7, 146, 2, 2, 1414, 1415, 7, 248, 2, 2, 1415, 1418, 5, 304, 153, 2, 1416, 1417, 7, 246, 2, 2, 1417, 1419, 5, 304, 153, 2, 1418, 1416, 3, 2, 2, 2, 1418, 1419, 3, 2, 2, 2, 1419, 1420, 3, 2, 2, 2, 1420, 1421, 7, 249, 2, 2, 1421, 1423, 3, 2, 2, 2, 1422, 1413, 3, 2, 2, 2, 1422, 1423, 3, 2, 2, 2, 1423, 161, 3, 2, 2, 2, 1424, 1428, 5, 164, 83, 2, 1425, 1428, 5, 166, 84, 2, 1426, 1428, 5, 168, 85, 2, 1427, 1424, 3, 2, 2, 2, 1427, 1425, 3, 2, 2, 2, 1427, 1426, 3, 2, 2, 2, 1428, 163, 3, 2, 2, 2, 1429, 1430, 7, 163, 2, 2, 1430, 1443, 5, 186, 94, 2, 1431, 1432, 7, 146, 2, 2, 1432, 1433, 7, 248, 2, 2, 1433, 1438, 5, 304, 153, 2, 1434, 1435, 7, 246, 2, 2, 1435, 1437, 5, 304, 153, 2, 1436, 1434, 3, 2, 2, 2, 1437, 1440, 3, 2, 2, 2, 1438, 1439, 3, 2, 2, 2, 1438, 1436, 3, 2, 2, 2, 1439, 1441, 3, 2, 2, 2, 1440, 1438, 3, 2, 2, 2, 1441, 1442, 7, 249, 2, 2, 1442, 1444, 3, 2, 2, 2, 1443, 1431, 3, 2, 2, 2, 1443, 1444, 3, 2, 2, 2, 1444, 165, 3, 2, 2, 2, 1445, 1446, 7, 163, 2, 2, 1446, 1447, 7, 15, 2, 2, 1447, 167, 3, 2, 2, 2, 1448, 1449, 7, 163, 2, 2, 1449, 1450, 7, 87, 2, 2, 1450, 1451, 5, 190, 96, 2, 1451, 169, 3, 2, 2, 2, 1452, 1453, 7, 95, 2, 2, 1453, 1454, 7, 68, 2, 2, 1454, 171, 3, 2, 2, 2, 1455, 1456, 7, 95, 2, 2, 1456, 1457, 7, 133, 2, 2, 1457, 1458, 7, 68, 2, 2, 1458, 173, 3, 2, 2, 2, 1459, 1460, 5, 352, 177, 2, 1460, 175, 3, 2, 2, 2, 1461, 1462, 5, 352, 177, 2, 1462, 177, 3, 2, 2, 2, 1463, 1464, 5, 352, 177, 2, 1464, 179, 3, 2, 2, 2, 1465, 1466, 5, 352, 177, 2, 1466, 181, 3, 2, 2, 2, 1467, 1468, 5, 352, 177, 2, 1468, 183, 3, 2, 2, 2, 1469, 1470, 5, 352, 177, 2, 1470, 185, 3, 2, 2, 2, 1471, 1476, 5, 356, 179, 2, 1472, 1473, 7, 244, 2, 2, 1473, 1475, 5, 356, 179, 2, 1474, 1472, 3, 2, 2, 2, 1475, 1478, 3, 2, 2, 2, 1476, 1474, 3, 2, 2, 2, 1476, 1477, 3, 2, 2, 2, 1477, 187, 3, 2, 2, 2, 1478, 1476, 3, 2, 2, 2, 1479, 1484, 5, 356, 179, 2, 1480, 1481, 7, 244, 2, 2, 1481, 1483, 5, 356, 179, 2, 1482, 1480, 3, 2, 2, 2, 1483, 1486, 3, 2, 2, 2, 1484, 1482, 3, 2, 2, 2, 1484, 1485, 3, 2, 2, 2, 1485, 189, 3, 2, 2, 2, 1486, 1484, 3, 2, 2, 2, 1487, 1488, 5, 352, 177, 2, 1488, 191, 3, 2, 2, 2, 1489, 1490, 5, 352, 177, 2, 1490, 193, 3, 2, 2, 2, 1491, 1494, 5, 186, 94, 2, 1492, 1494, 5, 188, 95, 2, 1493, 1491, 3, 2, 2, 2, 1493, 1492, 3, 2, 2, 2, 1494, 195, 3, 2, 2, 2, 1495, 1496, 7, 23, 2, 2, 1496, 1497, 7, 28, 2, 2, 1497, 1499, 5, 290, 146, 2, 1498, 1495, 3, 2, 2, 2, 1498, 1499, 3, 2, 2, 2, 1499, 1502, 3, 2, 2, 2, 1500, 1501, 7, 36, 2, 2, 1501, 1503, 5, 314, 158, 2, 1502, 1500, 3, 2, 2, 2, 1502, 1503, 3, 2, 2, 2, 1503, 1507, 3, 2, 2, 2, 1504, 1505, 7, 169, 2, 2, 1505, 1506, 7, 81, 2, 2, 1506, 1508, 5, 252, 127, 2, 1507, 1504, 3, 2, 2, 2, 1507, 1508, 3, 2, 2, 2, 1508, 1512, 3, 2, 2, 2, 1509, 1510, 7, 217, 2, 2, 1510, 1511, 7, 176, 2, 2, 1511, 1513, 5, 246, 124, 2, 1512, 1509, 3, 2, 2, 2, 1512, 1513, 3, 2, 2, 2, 1513, 1517, 3, 2, 2, 2, 1514, 1515, 7, 25, 2, 2, 1515, 1516, 7, 11, 2, 2, 1516, 1518, 5, 228, 115, 2, 1517, 1514, 3, 2, 2, 2, 1517, 1518, 3, 2, 2, 2, 1518, 1521, 3, 2, 2, 2, 1519, 1520, 7, 26, 2, 2, 1520, 1522, 5, 314, 158, 2, 1521, 1519, 3, 2, 2, 2, 1521, 1522, 3, 2, 2, 2, 1522, 1533, 3, 2, 2, 2, 1523, 1524, 7, 32, 2, 2, 1524, 1525, 7, 96, 2, 2, 1525, 1530, 5, 352, 177, 2, 1526, 1527, 7, 217, 2, 2, 1527, 1528, 7, 152, 2, 2, 1528, 1529, 7, 232, 2, 2, 1529, 1531, 7, 260, 2, 2, 1530, 1526, 3, 2, 2, 2, 1530, 1531, 3, 2, 2, 2, 1531, 1534, 3, 2, 2, 2, 1532, 1534, 7, 199, 2, 2, 1533, 1523, 3, 2, 2, 2, 1533, 1532, 3, 2, 2, 2, 1533, 1534, 3, 2, 2, 2, 1534, 1537, 3, 2, 2, 2, 1535, 1536, 7, 27, 2, 2, 1536, 1538, 5, 246, 124, 2, 1537, 1535, 3, 2, 2, 2, 1537, 1538, 3, 2, 2, 2, 1538, 197, 3, 2, 2, 2, 1539, 1544, 5, 200, 101, 2, 1540, 1541, 7, 246, 2, 2, 1541, 1543, 5, 200, 101, 2, 1542, 1540, 3, 2, 2, 2, 1543, 1546, 3, 2, 2, 2, 1544, 1542, 3, 2, 2, 2, 1544, 1545, 3, 2, 2, 2, 1545, 199, 3, 2, 2, 2, 1546, 1544, 3, 2, 2, 2, 1547, 1548, 5, 352, 177, 2, 1548, 1549, 7, 232, 2, 2, 1549, 1550, 5, 304, 153, 2, 1550, 201, 3, 2, 2, 2, 1551, 1552, 7, 248, 2, 2, 1552, 1555, 5, 192, 97, 2, 1553, 1554, 7, 36, 2, 2, 1554, 1556, 5, 314, 158, 2, 1555, 1553, 3, 2, 2, 2, 1555, 1556, 3, 2, 2, 2, 1556, 1565, 3, 2, 2, 2, 1557, 1558, 7, 246, 2, 2, 1558, 1561, 5, 356, 179, 2, 1559, 1560, 7, 36, 2, 2, 1560, 1562, 5, 314, 158, 2, 1561, 1559, 3, 2, 2, 2, 1561, 1562, 3, 2, 2, 2, 1562, 1564, 3, 2, 2, 2, 1563, 1557, 3, 2, 2, 2, 1564, 1567, 3, 2, 2, 2, 1565, 1563, 3, 2, 2, 2, 1565, 1566, 3, 2, 2, 2, 1566, 1568, 3, 2, 2, 2, 1567, 1565, 3, 2, 2, 2, 1568, 1569, 7, 249, 2, 2, 1569, 203, 3, 2, 2, 2, 1570, 1572, 5, 206, 104, 2, 1571, 1570, 3, 2, 2, 2, 1571, 1572, 3, 2, 2, 2, 1572, 1573, 3, 2, 2, 2, 1573, 1574, 5, 256, 129, 2, 1574, 205, 3, 2, 2, 2, 1575, 1576, 7, 217, 2, 2, 1576, 1581, 5, 272, 137, 2, 1577, 1578, 7, 246, 2, 2, 1578, 1580, 5, 272, 137, 2, 1579, 1577, 3, 2, 2, 2, 1580, 1583, 3, 2, 2, 2, 1581, 1579, 3, 2, 2, 2, 1581, 1582, 3, 2, 2, 2, 1582, 207, 3, 2, 2, 2, 1583, 1581, 3, 2, 2, 2, 1584, 1585, 7, 151, 2, 2, 1585, 1586, 7, 110, 2, 2, 1586, 1588, 5, 290, 146, 2, 1587, 1589, 7, 55, 2, 2, 1588, 1587, 3, 2, 2, 2, 1588, 1589, 3, 2, 2, 2, 1589, 1593, 3, 2, 2, 2, 1590, 1594, 7, 226, 2, 2, 1591, 1592, 7, 246, 2, 2, 1592, 1594, 7, 226, 2, 2, 1593, 1590, 3, 2, 2, 2, 1593, 1591, 3, 2, 2, 2, 1593, 1594, 3, 2, 2, 2, 1594, 1598, 3, 2, 2, 2, 1595, 1599, 7, 227, 2, 2, 1596, 1597, 7, 246, 2, 2, 1597, 1599, 7, 227, 2, 2, 1598, 1595, 3, 2, 2, 2, 1598, 1596, 3, 2, 2, 2, 1598, 1599, 3, 2, 2, 2, 1599, 1612, 3, 2, 2, 2, 1600, 1601, 7, 246, 2, 2, 1601, 1604, 5, 210, 106, 2, 1602, 1604, 5, 210, 106, 2, 1603, 1600, 3, 2, 2, 2, 1603, 1602, 3, 2, 2, 2, 1604, 1609, 3, 2, 2, 2, 1605, 1606, 7, 246, 2, 2, 1606, 1608, 5, 210, 106, 2, 1607, 1605, 3, 2, 2, 2, 1608, 1611, 3, 2, 2, 2, 1609, 1610, 3, 2, 2, 2, 1609, 1607, 3, 2, 2, 2, 1610, 1613, 3, 2, 2, 2, 1611, 1609, 3, 2, 2, 2, 1612, 1603, 3, 2, 2, 2, 1612, 1613, 3, 2, 2, 2, 1613, 209, 3, 2, 2, 2, 1614, 1615, 7, 83, 2, 2, 1615, 1616, 7, 110, 2, 2, 1616, 1617, 5, 290, 146, 2, 1617, 1618, 7, 225, 2, 2, 1618, 1619, 5, 186, 94, 2, 1619, 1621, 5, 290, 146, 2, 1620, 1622, 7, 55, 2, 2, 1621, 1620, 3, 2, 2, 2, 1621, 1622, 3, 2, 2, 2, 1622, 1624, 3, 2, 2, 2, 1623, 1625, 7, 226, 2, 2, 1624, 1623, 3, 2, 2, 2, 1624, 1625, 3, 2, 2, 2, 1625, 1627, 3, 2, 2, 2, 1626, 1628, 7, 227, 2, 2, 1627, 1626, 3, 2, 2, 2, 1627, 1628, 3, 2, 2, 2, 1628, 211, 3, 2, 2, 2, 1629, 1630, 5, 182, 92, 2, 1630, 1633, 5, 328, 165, 2, 1631, 1632, 7, 36, 2, 2, 1632, 1634, 5, 314, 158, 2, 1633, 1631, 3, 2, 2, 2, 1633, 1634, 3, 2, 2, 2, 1634, 213, 3, 2, 2, 2, 1635, 1636, 5, 216, 109, 2, 1636, 215, 3, 2, 2, 2, 1637, 1638, 5, 182, 92, 2, 1638, 1646, 5, 328, 165, 2, 1639, 1643, 5, 222, 112, 2, 1640, 1642, 5, 222, 112, 2, 1641, 1640, 3, 2, 2, 2, 1642, 1645, 3, 2, 2, 2, 1643, 1644, 3, 2, 2, 2, 1643, 1641, 3, 2, 2, 2, 1644, 1647, 3, 2, 2, 2, 1645, 1643, 3, 2, 2, 2, 1646, 1639, 3, 2, 2, 2, 1646, 1647, 3, 2, 2, 2, 1647, 1650, 3, 2, 2, 2, 1648, 1649, 7, 36, 2, 2, 1649, 1651, 5, 314, 158, 2, 1650, 1648, 3, 2, 2, 2, 1650, 1651, 3, 2, 2, 2, 1651, 1654, 3, 2, 2, 2, 1652, 1653, 7, 151, 2, 2, 1653, 1655, 7, 110, 2, 2, 1654, 1652, 3, 2, 2, 2, 1654, 1655, 3, 2, 2, 2, 1655, 217, 3, 2, 2, 2, 1656, 1657, 5, 192, 97, 2, 1657, 1660, 5, 328, 165, 2, 1658, 1659, 7, 36, 2, 2, 1659, 1661, 5, 314, 158, 2, 1660, 1658, 3, 2, 2, 2, 1660, 1661, 3, 2, 2, 2, 1661, 1669, 3, 2, 2, 2, 1662, 1666, 5, 222, 112, 2, 1663, 1665, 5, 222, 112, 2, 1664, 1663, 3, 2, 2, 2, 1665, 1668, 3, 2, 2, 2, 1666, 1667, 3, 2, 2, 2, 1666, 1664, 3, 2, 2, 2, 1667, 1670, 3, 2, 2, 2, 1668, 1666, 3, 2, 2, 2, 1669, 1662, 3, 2, 2, 2, 1669, 1670, 3, 2, 2, 2, 1670, 219, 3, 2, 2, 2, 1671, 1672, 5, 182, 92, 2, 1672, 1675, 5, 328, 165, 2, 1673, 1674, 7, 36, 2, 2, 1674, 1676, 5, 314, 158, 2, 1675, 1673, 3, 2, 2, 2, 1675, 1676, 3, 2, 2, 2, 1676, 1684, 3, 2, 2, 2, 1677, 1681, 5, 222, 112, 2, 1678, 1680, 5, 222, 112, 2, 1679, 1678, 3, 2, 2, 2, 1680, 1683, 3, 2, 2, 2, 1681, 1682, 3, 2, 2, 2, 1681, 1679, 3, 2, 2, 2, 1682, 1685, 3, 2, 2, 2, 1683, 1681, 3, 2, 2, 2, 1684, 1677, 3, 2, 2, 2, 1684, 1685, 3, 2, 2, 2, 1685, 221, 3, 2, 2, 2, 1686, 1688, 7, 133, 2, 2, 1687, 1686, 3, 2, 2, 2, 1687, 1688, 3, 2, 2, 2, 1688, 1689, 3, 2, 2, 2, 1689, 1692, 7, 134, 2, 2, 1690, 1692, 5, 224, 113, 2, 1691, 1687, 3, 2, 2, 2, 1691, 1690, 3, 2, 2, 2, 1692, 223, 3, 2, 2, 2, 1693, 1694, 7, 62, 2, 2, 1694, 1702, 5, 304, 153, 2, 1695, 1696, 7, 37, 2, 2, 1696, 1702, 5, 304, 153, 2, 1697, 1698, 7, 53, 2, 2, 1698, 1702, 5, 304, 153, 2, 1699, 1700, 7, 18, 2, 2, 1700, 1702, 5, 358, 180, 2, 1701, 1693, 3, 2, 2, 2, 1701, 1695, 3, 2, 2, 2, 1701, 1697, 3, 2, 2, 2, 1701, 1699, 3, 2, 2, 2, 1702, 225, 3, 2, 2, 2, 1703, 1704, 9, 12, 2, 2, 1704, 227, 3, 2, 2, 2, 1705, 1706, 9, 13, 2, 2, 1706, 229, 3, 2, 2, 2, 1707, 1712, 5, 232, 117, 2, 1708, 1709, 7, 246, 2, 2, 1709, 1711, 5, 232, 117, 2, 1710, 1708, 3, 2, 2, 2, 1711, 1714, 3, 2, 2, 2, 1712, 1713, 3, 2, 2, 2, 1712, 1710, 3, 2, 2, 2, 1713, 1717, 3, 2, 2, 2, 1714, 1712, 3, 2, 2, 2, 1715, 1716, 7, 246, 2, 2, 1716, 1718, 5, 234, 118, 2, 1717, 1715, 3, 2, 2, 2, 1717, 1718, 3, 2, 2, 2, 1718, 1721, 3, 2, 2, 2, 1719, 1721, 5, 234, 118, 2, 1720, 1707, 3, 2, 2, 2, 1720, 1719, 3, 2, 2, 2, 1721, 231, 3, 2, 2, 2, 1722, 1724, 7, 91, 2, 2, 1723, 1725, 5, 290, 146, 2, 1724, 1723, 3, 2, 2, 2, 1724, 1725, 3, 2, 2, 2, 1725, 1726, 3, 2, 2, 2, 1726, 1727, 7, 147, 2, 2, 1727, 1728, 5, 358, 180, 2, 1728, 233, 3, 2, 2, 2, 1729, 1731, 7, 155, 2, 2, 1730, 1732, 5, 290, 146, 2, 1731, 1730, 3, 2, 2, 2, 1731, 1732, 3, 2, 2, 2, 1732, 1733, 3, 2, 2, 2, 1733, 1734, 7, 248, 2, 2, 1734, 1735, 7, 146, 2, 2, 1735, 1741, 5, 236, 119, 2, 1736, 1737, 7, 246, 2, 2, 1737, 1738, 7, 146, 2, 2, 1738, 1740, 5, 236, 119, 2, 1739, 1736, 3, 2, 2, 2, 1740, 1743, 3, 2, 2, 2, 1741, 1742, 3, 2, 2, 2, 1741, 1739, 3, 2, 2, 2, 1742, 1744, 3, 2, 2, 2, 1743, 1741, 3, 2, 2, 2, 1744, 1745, 7, 249, 2, 2, 1745, 235, 3, 2, 2, 2, 1746, 1747, 7, 211, 2, 2, 1747, 1748, 5, 242, 122, 2, 1748, 1749, 5, 304, 153, 2, 1749, 1762, 3, 2, 2, 2, 1750, 1751, 5, 304, 153, 2, 1751, 1752, 5, 240, 121, 2, 1752, 1754, 3, 2, 2, 2, 1753, 1750, 3, 2, 2, 2, 1753, 1754, 3, 2, 2, 2, 1754, 1755, 3, 2, 2, 2, 1755, 1759, 7, 212, 2, 2, 1756, 1757, 5, 240, 121, 2, 1757, 1758, 5, 304, 153, 2, 1758, 1760, 3, 2, 2, 2, 1759, 1756, 3, 2, 2, 2, 1759, 1760, 3, 2, 2, 2, 1760, 1762, 3, 2, 2, 2, 1761, 1746, 3, 2, 2, 2, 1761, 1753, 3, 2, 2, 2, 1762, 237, 3, 2, 2, 2, 1763, 1764, 7, 32, 2, 2, 1764, 1765, 7, 96, 2, 2, 1765, 1770, 5, 356, 179, 2, 1766, 1767, 7, 217, 2, 2, 1767, 1768, 7, 152, 2, 2, 1768, 1769, 7, 232, 2, 2, 1769, 1771, 5, 358, 180, 2, 1770, 1766, 3, 2, 2, 2, 1770, 1771, 3, 2, 2, 2, 1771, 1774, 3, 2, 2, 2, 1772, 1774, 7, 199, 2, 2, 1773, 1763, 3, 2, 2, 2, 1773, 1772, 3, 2, 2, 2, 1774, 239, 3, 2, 2, 2, 1775, 1781, 3, 2, 2, 2, 1776, 1781, 7, 234, 2, 2, 1777, 1781, 7, 235, 2, 2, 1778, 1781, 7, 236, 2, 2, 1779, 1781, 7, 237, 2, 2, 1780, 1775, 3, 2, 2, 2, 1780, 1776, 3, 2, 2, 2, 1780, 1777, 3, 2, 2, 2, 1780, 1778, 3, 2, 2, 2, 1780, 1779, 3, 2, 2, 2, 1781, 241, 3, 2, 2, 2, 1782, 1791, 7, 232, 2, 2, 1783, 1791, 7, 233, 2, 2, 1784, 1791, 7, 115, 2, 2, 1785, 1791, 7, 165, 2, 2, 1786, 1791, 7, 164, 2, 2, 1787, 1791, 7, 17, 2, 2, 1788, 1791, 7, 96, 2, 2, 1789, 1791, 5, 240, 121, 2, 1790, 1782, 3, 2, 2, 2, 1790, 1783, 3, 2, 2, 2, 1790, 1784, 3, 2, 2, 2, 1790, 1785, 3, 2, 2, 2, 1790, 1786, 3, 2, 2, 2, 1790, 1787, 3, 2, 2, 2, 1790, 1788, 3, 2, 2, 2, 1790, 1789, 3, 2, 2, 2, 1791, 243, 3, 2, 2, 2, 1792, 1793, 7, 115, 2, 2, 1793, 1796, 5, 352, 177, 2, 1794, 1795, 9, 14, 2, 2, 1795, 1797, 7, 154, 2, 2, 1796, 1794, 3, 2, 2, 2, 1796, 1797, 3, 2, 2, 2, 1797, 245, 3, 2, 2, 2, 1798, 1799, 7, 248, 2, 2, 1799, 1804, 5, 254, 128, 2, 1800, 1801, 7, 246, 2, 2, 1801, 1803, 5, 254, 128, 2, 1802, 1800, 3, 2, 2, 2, 1803, 1806, 3, 2, 2, 2, 1804, 1802, 3, 2, 2, 2, 1804, 1805, 3, 2, 2, 2, 1805, 1807, 3, 2, 2, 2, 1806, 1804, 3, 2, 2, 2, 1807, 1808, 7, 249, 2, 2, 1808, 247, 3, 2, 2, 2, 1809, 1810, 7, 248, 2, 2, 1810, 1815, 5, 212, 107, 2, 1811, 1812, 7, 246, 2, 2, 1812, 1814, 5, 212, 107, 2, 1813, 1811, 3, 2, 2, 2, 1814, 1817, 3, 2, 2, 2, 1815, 1816, 3, 2, 2, 2, 1815, 1813, 3, 2, 2, 2, 1816, 1818, 3, 2, 2, 2, 1817, 1815, 3, 2, 2, 2, 1818, 1819, 7, 249, 2, 2, 1819, 249, 3, 2, 2, 2, 1820, 1825, 5, 304, 153, 2, 1821, 1822, 7, 246, 2, 2, 1822, 1824, 5, 304, 153, 2, 1823, 1821, 3, 2, 2, 2, 1824, 1827, 3, 2, 2, 2, 1825, 1823, 3, 2, 2, 2, 1825, 1826, 3, 2, 2, 2, 1826, 251, 3, 2, 2, 2, 1827, 1825, 3, 2, 2, 2, 1828, 1838, 7, 54, 2, 2, 1829, 1830, 7, 73, 2, 2, 1830, 1831, 7, 193, 2, 2, 1831, 1832, 7, 28, 2, 2, 1832, 1836, 5, 314, 158, 2, 1833, 1834, 7, 65, 2, 2, 1834, 1835, 7, 28, 2, 2, 1835, 1837, 5, 314, 158, 2, 1836, 1833, 3, 2, 2, 2, 1836, 1837, 3, 2, 2, 2, 1837, 1839, 3, 2, 2, 2, 1838, 1829, 3, 2, 2, 2, 1838, 1839, 3, 2, 2, 2, 1839, 1844, 3, 2, 2, 2, 1840, 1841, 7, 117, 2, 2, 1841, 1842, 7, 193, 2, 2, 1842, 1843, 7, 28, 2, 2, 1843, 1845, 5, 314, 158, 2, 1844, 1840, 3, 2, 2, 2, 1844, 1845, 3, 2, 2, 2, 1845, 253, 3, 2, 2, 2, 1846, 1849, 5, 356, 179, 2, 1847, 1848, 7, 232, 2, 2, 1848, 1850, 5, 304, 153, 2, 1849, 1847, 3, 2, 2, 2, 1849, 1850, 3, 2, 2, 2, 1850, 255, 3, 2, 2, 2, 1851, 1862, 5, 258, 130, 2, 1852, 1853, 7, 140, 2, 2, 1853, 1854, 7, 28, 2, 2, 1854, 1859, 5, 262, 132, 2, 1855, 1856, 7, 246, 2, 2, 1856, 1858, 5, 262, 132, 2, 1857, 1855, 3, 2, 2, 2, 1858, 1861, 3, 2, 2, 2, 1859, 1857, 3, 2, 2, 2, 1859, 1860, 3, 2, 2, 2, 1860, 1863, 3, 2, 2, 2, 1861, 1859, 3, 2, 2, 2, 1862, 1852, 3, 2, 2, 2, 1862, 1863, 3, 2, 2, 2, 1863, 1870, 3, 2, 2, 2, 1864, 1865, 7, 116, 2, 2, 1865, 1868, 5, 304, 153, 2, 1866, 1867, 7, 136, 2, 2, 1867, 1869, 7, 260, 2, 2, 1868, 1866, 3, 2, 2, 2, 1868, 1869, 3, 2, 2, 2, 1869, 1871, 3, 2, 2, 2, 1870, 1864, 3, 2, 2, 2, 1870, 1871, 3, 2, 2, 2, 1871, 257, 3, 2, 2, 2, 1872, 1873, 8, 130, 1, 2, 1873, 1874, 5, 260, 131, 2, 1874, 1889, 3, 2, 2, 2, 1875, 1876, 12, 4, 2, 2, 1876, 1878, 7, 102, 2, 2, 1877, 1879, 5, 274, 138, 2, 1878, 1877, 3, 2, 2, 2, 1878, 1879, 3, 2, 2, 2, 1879, 1880, 3, 2, 2, 2, 1880, 1888, 5, 258, 130, 5, 1881, 1882, 12, 3, 2, 2, 1882, 1884, 9, 15, 2, 2, 1883, 1885, 5, 274, 138, 2, 1884, 1883, 3, 2, 2, 2, 1884, 1885, 3, 2, 2, 2, 1885, 1886, 3, 2, 2, 2, 1886, 1888, 5, 258, 130, 4, 1887, 1875, 3, 2, 2, 2, 1887, 1881, 3, 2, 2, 2, 1888, 1891, 3, 2, 2, 2, 1889, 1887, 3, 2, 2, 2, 1889, 1890, 3, 2, 2, 2, 1890, 259, 3, 2, 2, 2, 1891, 1889, 3, 2, 2, 2, 1892, 1909, 5, 264, 133, 2, 1893, 1894, 7, 190, 2, 2, 1894, 1909, 5, 186, 94, 2, 1895, 1896, 7, 212, 2, 2, 1896, 1901, 5, 304, 153, 2, 1897, 1898, 7, 246, 2, 2, 1898, 1900, 5, 304, 153, 2, 1899, 1897, 3, 2, 2, 2, 1900, 1903, 3, 2, 2, 2, 1901, 1899, 3, 2, 2, 2, 1901, 1902, 3, 2, 2, 2, 1902, 1909, 3, 2, 2, 2, 1903, 1901, 3, 2, 2, 2, 1904, 1905, 7, 248, 2, 2, 1905, 1906, 5, 256, 129, 2, 1906, 1907, 7, 249, 2, 2, 1907, 1909, 3, 2, 2, 2, 1908, 1892, 3, 2, 2, 2, 1908, 1893, 3, 2, 2, 2, 1908, 1895, 3, 2, 2, 2, 1908, 1904, 3, 2, 2, 2, 1909, 261, 3, 2, 2, 2, 1910, 1912, 5, 302, 152, 2, 1911, 1913, 9, 16, 2, 2, 1912, 1911, 3, 2, 2, 2, 1912, 1913, 3, 2, 2, 2, 1913, 1916, 3, 2, 2, 2, 1914, 1915, 7, 135, 2, 2, 1915, 1917, 9, 17, 2, 2, 1916, 1914, 3, 2, 2, 2, 1916, 1917, 3, 2, 2, 2, 1917, 263, 3, 2, 2, 2, 1918, 1920, 7, 175, 2, 2, 1919, 1921, 5, 274, 138, 2, 1920, 1919, 3, 2, 2, 2, 1920, 1921, 3, 2, 2, 2, 1921, 1923, 3, 2, 2, 2, 1922, 1924, 7, 185, 2, 2, 1923, 1922, 3, 2, 2, 2, 1923, 1924, 3, 2, 2, 2, 1924, 1925, 3, 2, 2, 2, 1925, 1930, 5, 276, 139, 2, 1926, 1927, 7, 246, 2, 2, 1927, 1929, 5, 276, 139, 2, 1928, 1926, 3, 2, 2, 2, 1929, 1932, 3, 2, 2, 2, 1930, 1928, 3, 2, 2, 2, 1930, 1931, 3, 2, 2, 2, 1931, 1942, 3, 2, 2, 2, 1932, 1930, 3, 2, 2, 2, 1933, 1934, 7, 84, 2, 2, 1934, 1939, 5, 278, 140, 2, 1935, 1936, 7, 246, 2, 2, 1936, 1938, 5, 278, 140, 2, 1937, 1935, 3, 2, 2, 2, 1938, 1941, 3, 2, 2, 2, 1939, 1937, 3, 2, 2, 2, 1939, 1940, 3, 2, 2, 2, 1940, 1943, 3, 2, 2, 2, 1941, 1939, 3, 2, 2, 2, 1942, 1933, 3, 2, 2, 2, 1942, 1943, 3, 2, 2, 2, 1943, 1946, 3, 2, 2, 2, 1944, 1945, 7, 216, 2, 2, 1945, 1947, 5, 306, 154, 2, 1946, 1944, 3, 2, 2, 2, 1946, 1947, 3, 2, 2, 2, 1947, 1951, 3, 2, 2, 2, 1948, 1949, 7, 89, 2, 2, 1949, 1950, 7, 28, 2, 2, 1950, 1952, 5, 266, 134, 2, 1951, 1948, 3, 2, 2, 2, 1951, 1952, 3, 2, 2, 2, 1952, 1955, 3, 2, 2, 2, 1953, 1954, 7, 92, 2, 2, 1954, 1956, 5, 306, 154, 2, 1955, 1953, 3, 2, 2, 2, 1955, 1956, 3, 2, 2, 2, 1956, 265, 3, 2, 2, 2, 1957, 1959, 5, 274, 138, 2, 1958, 1957, 3, 2, 2, 2, 1958, 1959, 3, 2, 2, 2, 1959, 1960, 3, 2, 2, 2, 1960, 1965, 5, 268, 135, 2, 1961, 1962, 7, 246, 2, 2, 1962, 1964, 5, 268, 135, 2, 1963, 1961, 3, 2, 2, 2, 1964, 1967, 3, 2, 2, 2, 1965, 1963, 3, 2, 2, 2, 1965, 1966, 3, 2, 2, 2, 1966, 267, 3, 2, 2, 2, 1967, 1965, 3, 2, 2, 2, 1968, 1969, 5, 270, 136, 2, 1969, 269, 3, 2, 2, 2, 1970, 1979, 7, 248, 2, 2, 1971, 1976, 5, 302, 152, 2, 1972, 1973, 7, 246, 2, 2, 1973, 1975, 5, 302, 152, 2, 1974, 1972, 3, 2, 2, 2, 1975, 1978, 3, 2, 2, 2, 1976, 1974, 3, 2, 2, 2, 1976, 1977, 3, 2, 2, 2, 1977, 1980, 3, 2, 2, 2, 1978, 1976, 3, 2, 2, 2, 1979, 1971, 3, 2, 2, 2, 1979, 1980, 3, 2, 2, 2, 1980, 1981, 3, 2, 2, 2, 1981, 1984, 7, 249, 2, 2, 1982, 1984, 5, 302, 152, 2, 1983, 1970, 3, 2, 2, 2, 1983, 1982, 3, 2, 2, 2, 1984, 271, 3, 2, 2, 2, 1985, 1987, 5, 356, 179, 2, 1986, 1988, 5, 290, 146, 2, 1987, 1986, 3, 2, 2, 2, 1987, 1988, 3, 2, 2, 2, 1988, 1989, 3, 2, 2, 2, 1989, 1990, 7, 11, 2, 2, 1990, 1991, 5, 296, 149, 2, 1991, 273, 3, 2, 2, 2, 1992, 1993, 9, 18, 2, 2, 1993, 275, 3, 2, 2, 2, 1994, 1999, 5, 302, 152, 2, 1995, 1997, 7, 11, 2, 2, 1996, 1995, 3, 2, 2, 2, 1996, 1997, 3, 2, 2, 2, 1997, 1998, 3, 2, 2, 2, 1998, 2000, 5, 356, 179, 2, 1999, 1996, 3, 2, 2, 2, 1999, 2000, 3, 2, 2, 2, 2000, 2007, 3, 2, 2, 2, 2001, 2002, 5, 352, 177, 2, 2002, 2003, 7, 244, 2, 2, 2003, 2004, 7, 240, 2, 2, 2004, 2007, 3, 2, 2, 2, 2005, 2007, 7, 240, 2, 2, 2006, 1994, 3, 2, 2, 2, 2006, 2001, 3, 2, 2, 2, 2006, 2005, 3, 2, 2, 2, 2007, 277, 3, 2, 2, 2, 2008, 2009, 8, 140, 1, 2, 2009, 2010, 5, 284, 143, 2, 2010, 2024, 3, 2, 2, 2, 2011, 2020, 12, 4, 2, 2, 2012, 2013, 7, 40, 2, 2, 2013, 2014, 7, 109, 2, 2, 2014, 2021, 5, 284, 143, 2, 2015, 2016, 5, 280, 141, 2, 2016, 2017, 7, 109, 2, 2, 2017, 2018, 5, 278, 140, 2, 2018, 2019, 5, 282, 142, 2, 2019, 2021, 3, 2, 2, 2, 2020, 2012, 3, 2, 2, 2, 2020, 2015, 3, 2, 2, 2, 2021, 2023, 3, 2, 2, 2, 2022, 2011, 3, 2, 2, 2, 2023, 2026, 3, 2, 2, 2, 2024, 2022, 3, 2, 2, 2, 2024, 2025, 3, 2, 2, 2, 2025, 279, 3, 2, 2, 2, 2026, 2024, 3, 2, 2, 2, 2027, 2029, 7, 99, 2, 2, 2028, 2027, 3, 2, 2, 2, 2028, 2029, 3, 2, 2, 2, 2029, 2059, 3, 2, 2, 2, 2030, 2032, 7, 114, 2, 2, 2031, 2033, 7, 99, 2, 2, 2032, 2031, 3, 2, 2, 2, 2032, 2033, 3, 2, 2, 2, 2033, 2059, 3, 2, 2, 2, 2034, 2036, 7, 166, 2, 2, 2035, 2037, 7, 99, 2, 2, 2036, 2035, 3, 2, 2, 2, 2036, 2037, 3, 2, 2, 2, 2037, 2059, 3, 2, 2, 2, 2038, 2040, 7, 114, 2, 2, 2039, 2041, 7, 142, 2, 2, 2040, 2039, 3, 2, 2, 2, 2040, 2041, 3, 2, 2, 2, 2041, 2059, 3, 2, 2, 2, 2042, 2044, 7, 166, 2, 2, 2043, 2045, 7, 142, 2, 2, 2044, 2043, 3, 2, 2, 2, 2044, 2045, 3, 2, 2, 2, 2045, 2059, 3, 2, 2, 2, 2046, 2048, 7, 85, 2, 2, 2047, 2049, 7, 142, 2, 2, 2048, 2047, 3, 2, 2, 2, 2048, 2049, 3, 2, 2, 2, 2049, 2059, 3, 2, 2, 2, 2050, 2051, 7, 114, 2, 2, 2051, 2059, 7, 178, 2, 2, 2052, 2053, 7, 166, 2, 2, 2053, 2059, 7, 178, 2, 2, 2054, 2055, 7, 114, 2, 2, 2055, 2059, 7, 9, 2, 2, 2056, 2057, 7, 166, 2, 2, 2057, 2059, 7, 9, 2, 2, 2058, 2028, 3, 2, 2, 2, 2058, 2030, 3, 2, 2, 2, 2058, 2034, 3, 2, 2, 2, 2058, 2038, 3, 2, 2, 2, 2058, 2042, 3, 2, 2, 2, 2058, 2046, 3, 2, 2, 2, 2058, 2050, 3, 2, 2, 2, 2058, 2052, 3, 2, 2, 2, 2058, 2054, 3, 2, 2, 2, 2058, 2056, 3, 2, 2, 2, 2059, 281, 3, 2, 2, 2, 2060, 2061, 7, 137, 2, 2, 2061, 2075, 5, 306, 154, 2, 2062, 2063, 7, 207, 2, 2, 2063, 2064, 7, 248, 2, 2, 2064, 2069, 5, 356, 179, 2, 2065, 2066, 7, 246, 2, 2, 2066, 2068, 5, 356, 179, 2, 2067, 2065, 3, 2, 2, 2, 2068, 2071, 3, 2, 2, 2, 2069, 2067, 3, 2, 2, 2, 2069, 2070, 3, 2, 2, 2, 2070, 2072, 3, 2, 2, 2, 2071, 2069, 3, 2, 2, 2, 2072, 2073, 7, 249, 2, 2, 2073, 2075, 3, 2, 2, 2, 2074, 2060, 3, 2, 2, 2, 2074, 2062, 3, 2, 2, 2, 2075, 283, 3, 2, 2, 2, 2076, 2089, 5, 288, 145, 2, 2077, 2078, 7, 192, 2, 2, 2078, 2079, 5, 286, 144, 2, 2079, 2080, 7, 248, 2, 2, 2080, 2081, 5, 304, 153, 2, 2081, 2087, 7, 249, 2, 2, 2082, 2083, 7, 158, 2, 2, 2083, 2084, 7, 248, 2, 2, 2084, 2085, 5, 304, 153, 2, 2085, 2086, 7, 249, 2, 2, 2086, 2088, 3, 2, 2, 2, 2087, 2082, 3, 2, 2, 2, 2087, 2088, 3, 2, 2, 2, 2088, 2090, 3, 2, 2, 2, 2089, 2077, 3, 2, 2, 2, 2089, 2090, 3, 2, 2, 2, 2090, 285, 3, 2, 2, 2, 2091, 2092, 9, 19, 2, 2, 2092, 287, 3, 2, 2, 2, 2093, 2101, 5, 294, 148, 2, 2094, 2096, 7, 11, 2, 2, 2095, 2094, 3, 2, 2, 2, 2095, 2096, 3, 2, 2, 2, 2096, 2097, 3, 2, 2, 2, 2097, 2099, 5, 356, 179, 2, 2098, 2100, 5, 290, 146, 2, 2099, 2098, 3, 2, 2, 2, 2099, 2100, 3, 2, 2, 2, 2100, 2102, 3, 2, 2, 2, 2101, 2095, 3, 2, 2, 2, 2101, 2102, 3, 2, 2, 2, 2102, 289, 3, 2, 2, 2, 2103, 2104, 7, 248, 2, 2, 2104, 2109, 5, 192, 97, 2, 2105, 2106, 7, 246, 2, 2, 2106, 2108, 5, 192, 97, 2, 2107, 2105, 3, 2, 2, 2, 2108, 2111, 3, 2, 2, 2, 2109, 2107, 3, 2, 2, 2, 2109, 2110, 3, 2, 2, 2, 2110, 2112, 3, 2, 2, 2, 2111, 2109, 3, 2, 2, 2, 2112, 2113, 7, 249, 2, 2, 2113, 291, 3, 2, 2, 2, 2114, 2115, 7, 248, 2, 2, 2115, 2120, 5, 192, 97, 2, 2116, 2117, 7, 246, 2, 2, 2117, 2119, 5, 192, 97, 2, 2118, 2116, 3, 2, 2, 2, 2119, 2122, 3, 2, 2, 2, 2120, 2118, 3, 2, 2, 2, 2120, 2121, 3, 2, 2, 2, 2121, 2123, 3, 2, 2, 2, 2122, 2120, 3, 2, 2, 2, 2123, 2124, 7, 249, 2, 2, 2124, 293, 3, 2, 2, 2, 2125, 2133, 5, 194, 98, 2, 2126, 2128, 7, 113, 2, 2, 2127, 2126, 3, 2, 2, 2, 2127, 2128, 3, 2, 2, 2, 2128, 2129, 3, 2, 2, 2, 2129, 2133, 5, 296, 149, 2, 2130, 2133, 5, 298, 150, 2, 2131, 2133, 5, 300, 151, 2, 2132, 2125, 3, 2, 2, 2, 2132, 2127, 3, 2, 2, 2, 2132, 2130, 3, 2, 2, 2, 2132, 2131, 3, 2, 2, 2, 2133, 295, 3, 2, 2, 2, 2134, 2135, 7, 248, 2, 2, 2135, 2136, 5, 204, 103, 2, 2136, 2137, 7, 249, 2, 2, 2137, 297, 3, 2, 2, 2, 2138, 2139, 7, 203, 2, 2, 2139, 2140, 7, 248, 2, 2, 2140, 2145, 5, 304, 153, 2, 2141, 2142, 7, 246, 2, 2, 2142, 2144, 5, 304, 153, 2, 2143, 2141, 3, 2, 2, 2, 2144, 2147, 3, 2, 2, 2, 2145, 2143, 3, 2, 2, 2, 2145, 2146, 3, 2, 2, 2, 2146, 2148, 3, 2, 2, 2, 2147, 2145, 3, 2, 2, 2, 2148, 2151, 7, 249, 2, 2, 2149, 2150, 7, 217, 2, 2, 2150, 2152, 7, 141, 2, 2, 2151, 2149, 3, 2, 2, 2, 2151, 2152, 3, 2, 2, 2, 2152, 299, 3, 2, 2, 2, 2153, 2154, 7, 248, 2, 2, 2154, 2155, 5, 278, 140, 2, 2155, 2156, 7, 249, 2, 2, 2156, 301, 3, 2, 2, 2, 2157, 2160, 5, 192, 97, 2, 2158, 2160, 5, 304, 153, 2, 2159, 2157, 3, 2, 2, 2, 2159, 2158, 3, 2, 2, 2, 2160, 303, 3, 2, 2, 2, 2161, 2162, 5, 306, 154, 2, 2162, 305, 3, 2, 2, 2, 2163, 2164, 8, 154, 1, 2, 2164, 2166, 5, 310, 156, 2, 2165, 2167, 5, 308, 155, 2, 2166, 2165, 3, 2, 2, 2, 2166, 2167, 3, 2, 2, 2, 2167, 2171, 3, 2, 2, 2, 2168, 2169, 7, 133, 2, 2, 2169, 2171, 5, 306, 154, 5, 2170, 2163, 3, 2, 2, 2, 2170, 2168, 3, 2, 2, 2, 2171, 2180, 3, 2, 2, 2, 2172, 2173, 12, 4, 2, 2, 2173, 2174, 7, 7, 2, 2, 2174, 2179, 5, 306, 154, 5, 2175, 2176, 12, 3, 2, 2, 2176, 2177, 7, 139, 2, 2, 2177, 2179, 5, 306, 154, 4, 2178, 2172, 3, 2, 2, 2, 2178, 2175, 3, 2, 2, 2, 2179, 2182, 3, 2, 2, 2, 2180, 2178, 3, 2, 2, 2, 2180, 2181, 3, 2, 2, 2, 2181, 307, 3, 2, 2, 2, 2182, 2180, 3, 2, 2, 2, 2183, 2184, 5, 316, 159, 2, 2184, 2185, 5, 310, 156, 2, 2185, 2242, 3, 2, 2, 2, 2186, 2187, 5, 316, 159, 2, 2187, 2188, 5, 318, 160, 2, 2188, 2189, 5, 296, 149, 2, 2189, 2242, 3, 2, 2, 2, 2190, 2192, 7, 133, 2, 2, 2191, 2190, 3, 2, 2, 2, 2191, 2192, 3, 2, 2, 2, 2192, 2193, 3, 2, 2, 2, 2193, 2194, 7, 17, 2, 2, 2194, 2195, 5, 310, 156, 2, 2195, 2196, 7, 7, 2, 2, 2196, 2197, 5, 310, 156, 2, 2197, 2242, 3, 2, 2, 2, 2198, 2200, 7, 133, 2, 2, 2199, 2198, 3, 2, 2, 2, 2199, 2200, 3, 2, 2, 2, 2200, 2201, 3, 2, 2, 2, 2201, 2202, 7, 96, 2, 2, 2202, 2203, 7, 248, 2, 2, 2203, 2208, 5, 304, 153, 2, 2204, 2205, 7, 246, 2, 2, 2205, 2207, 5, 304, 153, 2, 2206, 2204, 3, 2, 2, 2, 2207, 2210, 3, 2, 2, 2, 2208, 2206, 3, 2, 2, 2, 2208, 2209, 3, 2, 2, 2, 2209, 2211, 3, 2, 2, 2, 2210, 2208, 3, 2, 2, 2, 2211, 2212, 7, 249, 2, 2, 2212, 2242, 3, 2, 2, 2, 2213, 2215, 7, 133, 2, 2, 2214, 2213, 3, 2, 2, 2, 2214, 2215, 3, 2, 2, 2, 2215, 2216, 3, 2, 2, 2, 2216, 2217, 7, 96, 2, 2, 2217, 2242, 5, 296, 149, 2, 2218, 2220, 7, 133, 2, 2, 2219, 2218, 3, 2, 2, 2, 2219, 2220, 3, 2, 2, 2, 2220, 2221, 3, 2, 2, 2, 2221, 2222, 7, 115, 2, 2, 2222, 2225, 5, 310, 156, 2, 2223, 2224, 7, 64, 2, 2, 2224, 2226, 5, 310, 156, 2, 2225, 2223, 3, 2, 2, 2, 2225, 2226, 3, 2, 2, 2, 2226, 2242, 3, 2, 2, 2, 2227, 2228, 7, 164, 2, 2, 2228, 2242, 5, 310, 156, 2, 2229, 2231, 7, 108, 2, 2, 2230, 2232, 7, 133, 2, 2, 2231, 2230, 3, 2, 2, 2, 2231, 2232, 3, 2, 2, 2, 2232, 2233, 3, 2, 2, 2, 2233, 2242, 7, 134, 2, 2, 2234, 2236, 7, 108, 2, 2, 2235, 2237, 7, 133, 2, 2, 2236, 2235, 3, 2, 2, 2, 2236, 2237, 3, 2, 2, 2, 2237, 2238, 3, 2, 2, 2, 2238, 2239, 7, 59, 2, 2, 2239, 2240, 7, 84, 2, 2, 2240, 2242, 5, 310, 156, 2, 2241, 2183, 3, 2, 2, 2, 2241, 2186, 3, 2, 2, 2, 2241, 2191, 3, 2, 2, 2, 2241, 2199, 3, 2, 2, 2, 2241, 2214, 3, 2, 2, 2, 2241, 2219, 3, 2, 2, 2, 2241, 2227, 3, 2, 2, 2, 2241, 2229, 3, 2, 2, 2, 2241, 2234, 3, 2, 2, 2, 2242, 309, 3, 2, 2, 2, 2243, 2244, 8, 156, 1, 2, 2244, 2248, 5, 312, 157, 2, 2245, 2246, 9, 20, 2, 2, 2246, 2248, 5, 310, 156, 6, 2247, 2243, 3, 2, 2, 2, 2247, 2245, 3, 2, 2, 2, 2248, 2260, 3, 2, 2, 2, 2249, 2250, 12, 5, 2, 2, 2250, 2251, 9, 21, 2, 2, 2251, 2259, 5, 310, 156, 6, 2252, 2253, 12, 4, 2, 2, 2253, 2254, 9, 20, 2, 2, 2254, 2259, 5, 310, 156, 5, 2255, 2256, 12, 3, 2, 2, 2256, 2257, 7, 243, 2, 2, 2257, 2259, 5, 310, 156, 4, 2258, 2249, 3, 2, 2, 2, 2258, 2252, 3, 2, 2, 2, 2258, 2255, 3, 2, 2, 2, 2259, 2262, 3, 2, 2, 2, 2260, 2258, 3, 2, 2, 2, 2260, 2261, 3, 2, 2, 2, 2261, 311, 3, 2, 2, 2, 2262, 2260, 3, 2, 2, 2, 2263, 2264, 8, 157, 1, 2, 2264, 2510, 7, 134, 2, 2, 2265, 2510, 5, 322, 162, 2, 2266, 2267, 5, 356, 179, 2, 2267, 2268, 5, 314, 158, 2, 2268, 2510, 3, 2, 2, 2, 2269, 2270, 7, 269, 2, 2, 2270, 2510, 5, 314, 158, 2, 2271, 2510, 5, 358, 180, 2, 2272, 2510, 5, 320, 161, 2, 2273, 2510, 5, 314, 158, 2, 2274, 2510, 7, 259, 2, 2, 2275, 2510, 7, 255, 2, 2, 2276, 2277, 7, 149, 2, 2, 2277, 2278, 7, 248, 2, 2, 2278, 2279, 5, 310, 156, 2, 2279, 2280, 7, 96, 2, 2, 2280, 2281, 5, 310, 156, 2, 2281, 2282, 7, 249, 2, 2, 2282, 2510, 3, 2, 2, 2, 2283, 2284, 7, 248, 2, 2, 2284, 2287, 5, 304, 153, 2, 2285, 2286, 7, 11, 2, 2, 2286, 2288, 5, 328, 165, 2, 2287, 2285, 3, 2, 2, 2, 2287, 2288, 3, 2, 2, 2, 2288, 2297, 3, 2, 2, 2, 2289, 2290, 7, 246, 2, 2, 2290, 2293, 5, 304, 153, 2, 2291, 2292, 7, 11, 2, 2, 2292, 2294, 5, 328, 165, 2, 2293, 2291, 3, 2, 2, 2, 2293, 2294, 3, 2, 2, 2, 2294, 2296, 3, 2, 2, 2, 2295, 2289, 3, 2, 2, 2, 2296, 2299, 3, 2, 2, 2, 2297, 2298, 3, 2, 2, 2, 2297, 2295, 3, 2, 2, 2, 2298, 2300, 3, 2, 2, 2, 2299, 2297, 3, 2, 2, 2, 2300, 2301, 7, 249, 2, 2, 2301, 2510, 3, 2, 2, 2, 2302, 2303, 7, 169, 2, 2, 2303, 2304, 7, 248, 2, 2, 2304, 2309, 5, 304, 153, 2, 2305, 2306, 7, 246, 2, 2, 2306, 2308, 5, 304, 153, 2, 2307, 2305, 3, 2, 2, 2, 2308, 2311, 3, 2, 2, 2, 2309, 2307, 3, 2, 2, 2, 2309, 2310, 3, 2, 2, 2, 2310, 2312, 3, 2, 2, 2, 2311, 2309, 3, 2, 2, 2, 2312, 2313, 7, 249, 2, 2, 2313, 2510, 3, 2, 2, 2, 2314, 2315, 5, 190, 96, 2, 2315, 2316, 7, 248, 2, 2, 2316, 2317, 7, 240, 2, 2, 2317, 2319, 7, 249, 2, 2, 2318, 2320, 5, 336, 169, 2, 2319, 2318, 3, 2, 2, 2, 2319, 2320, 3, 2, 2, 2, 2320, 2322, 3, 2, 2, 2, 2321, 2323, 5, 338, 170, 2, 2322, 2321, 3, 2, 2, 2, 2322, 2323, 3, 2, 2, 2, 2323, 2510, 3, 2, 2, 2, 2324, 2325, 5, 190, 96, 2, 2325, 2337, 7, 248, 2, 2, 2326, 2328, 5, 274, 138, 2, 2327, 2326, 3, 2, 2, 2, 2327, 2328, 3, 2, 2, 2, 2328, 2329, 3, 2, 2, 2, 2329, 2334, 5, 304, 153, 2, 2330, 2331, 7, 246, 2, 2, 2331, 2333, 5, 304, 153, 2, 2332, 2330, 3, 2, 2, 2, 2333, 2336, 3, 2, 2, 2, 2334, 2332, 3, 2, 2, 2, 2334, 2335, 3, 2, 2, 2, 2335, 2338, 3, 2, 2, 2, 2336, 2334, 3, 2, 2, 2, 2337, 2327, 3, 2, 2, 2, 2337, 2338, 3, 2, 2, 2, 2338, 2349, 3, 2, 2, 2, 2339, 2340, 7, 140, 2, 2, 2340, 2341, 7, 28, 2, 2, 2341, 2346, 5, 262, 132, 2, 2342, 2343, 7, 246, 2, 2, 2343, 2345, 5, 262, 132, 2, 2344, 2342, 3, 2, 2, 2, 2345, 2348, 3, 2, 2, 2, 2346, 2344, 3, 2, 2, 2, 2346, 2347, 3, 2, 2, 2, 2347, 2350, 3, 2, 2, 2, 2348, 2346, 3, 2, 2, 2, 2349, 2339, 3, 2, 2, 2, 2349, 2350, 3, 2, 2, 2, 2350, 2351, 3, 2, 2, 2, 2351, 2353, 7, 249, 2, 2, 2352, 2354, 5, 336, 169, 2, 2353, 2352, 3, 2, 2, 2, 2353, 2354, 3, 2, 2, 2, 2354, 2356, 3, 2, 2, 2, 2355, 2357, 5, 338, 170, 2, 2356, 2355, 3, 2, 2, 2, 2356, 2357, 3, 2, 2, 2, 2357, 2510, 3, 2, 2, 2, 2358, 2359, 5, 356, 179, 2, 2359, 2360, 7, 256, 2, 2, 2360, 2361, 5, 304, 153, 2, 2361, 2510, 3, 2, 2, 2, 2362, 2371, 7, 248, 2, 2, 2363, 2368, 5, 356, 179, 2, 2364, 2365, 7, 246, 2, 2, 2365, 2367, 5, 356, 179, 2, 2366, 2364, 3, 2, 2, 2, 2367, 2370, 3, 2, 2, 2, 2368, 2366, 3, 2, 2, 2, 2368, 2369, 3, 2, 2, 2, 2369, 2372, 3, 2, 2, 2, 2370, 2368, 3, 2, 2, 2, 2371, 2363, 3, 2, 2, 2, 2371, 2372, 3, 2, 2, 2, 2372, 2373, 3, 2, 2, 2, 2373, 2374, 7, 249, 2, 2, 2374, 2375, 7, 256, 2, 2, 2375, 2510, 5, 304, 153, 2, 2376, 2377, 7, 248, 2, 2, 2377, 2378, 5, 204, 103, 2, 2378, 2379, 7, 249, 2, 2, 2379, 2510, 3, 2, 2, 2, 2380, 2381, 7, 68, 2, 2, 2381, 2382, 7, 248, 2, 2, 2382, 2383, 5, 204, 103, 2, 2383, 2384, 7, 249, 2, 2, 2384, 2510, 3, 2, 2, 2, 2385, 2386, 7, 30, 2, 2, 2386, 2388, 5, 310, 156, 2, 2387, 2389, 5, 334, 168, 2, 2388, 2387, 3, 2, 2, 2, 2389, 2390, 3, 2, 2, 2, 2390, 2388, 3, 2, 2, 2, 2390, 2391, 3, 2, 2, 2, 2391, 2394, 3, 2, 2, 2, 2392, 2393, 7, 61, 2, 2, 2393, 2395, 5, 304, 153, 2, 2394, 2392, 3, 2, 2, 2, 2394, 2395, 3, 2, 2, 2, 2395, 2396, 3, 2, 2, 2, 2396, 2397, 7, 63, 2, 2, 2397, 2510, 3, 2, 2, 2, 2398, 2400, 7, 30, 2, 2, 2399, 2401, 5, 334, 168, 2, 2400, 2399, 3, 2, 2, 2, 2401, 2402, 3, 2, 2, 2, 2402, 2400, 3, 2, 2, 2, 2402, 2403, 3, 2, 2, 2, 2403, 2406, 3, 2, 2, 2, 2404, 2405, 7, 61, 2, 2, 2405, 2407, 5, 304, 153, 2, 2406, 2404, 3, 2, 2, 2, 2406, 2407, 3, 2, 2, 2, 2407, 2408, 3, 2, 2, 2, 2408, 2409, 7, 63, 2, 2, 2409, 2510, 3, 2, 2, 2, 2410, 2411, 7, 31, 2, 2, 2411, 2412, 7, 248, 2, 2, 2412, 2413, 5, 304, 153, 2, 2413, 2414, 7, 11, 2, 2, 2414, 2415, 5, 328, 165, 2, 2415, 2416, 7, 249, 2, 2, 2416, 2510, 3, 2, 2, 2, 2417, 2418, 7, 197, 2, 2, 2418, 2419, 7, 248, 2, 2, 2419, 2420, 5, 304, 153, 2, 2420, 2421, 7, 11, 2, 2, 2421, 2422, 5, 328, 165, 2, 2422, 2423, 7, 249, 2, 2, 2423, 2510, 3, 2, 2, 2, 2424, 2425, 7, 10, 2, 2, 2425, 2434, 7, 250, 2, 2, 2426, 2431, 5, 304, 153, 2, 2427, 2428, 7, 246, 2, 2, 2428, 2430, 5, 304, 153, 2, 2429, 2427, 3, 2, 2, 2, 2430, 2433, 3, 2, 2, 2, 2431, 2429, 3, 2, 2, 2, 2431, 2432, 3, 2, 2, 2, 2432, 2435, 3, 2, 2, 2, 2433, 2431, 3, 2, 2, 2, 2434, 2426, 3, 2, 2, 2, 2434, 2435, 3, 2, 2, 2, 2435, 2436, 3, 2, 2, 2, 2436, 2510, 7, 251, 2, 2, 2437, 2510, 5, 356, 179, 2, 2438, 2510, 7, 42, 2, 2, 2439, 2443, 7, 44, 2, 2, 2440, 2441, 7, 248, 2, 2, 2441, 2442, 7, 260, 2, 2, 2442, 2444, 7, 249, 2, 2, 2443, 2440, 3, 2, 2, 2, 2443, 2444, 3, 2, 2, 2, 2444, 2510, 3, 2, 2, 2, 2445, 2449, 7, 45, 2, 2, 2446, 2447, 7, 248, 2, 2, 2447, 2448, 7, 260, 2, 2, 2448, 2450, 7, 249, 2, 2, 2449, 2446, 3, 2, 2, 2, 2449, 2450, 3, 2, 2, 2, 2450, 2510, 3, 2, 2, 2, 2451, 2455, 7, 119, 2, 2, 2452, 2453, 7, 248, 2, 2, 2453, 2454, 7, 260, 2, 2, 2454, 2456, 7, 249, 2, 2, 2455, 2452, 3, 2, 2, 2, 2455, 2456, 3, 2, 2, 2, 2456, 2510, 3, 2, 2, 2, 2457, 2461, 7, 120, 2, 2, 2458, 2459, 7, 248, 2, 2, 2459, 2460, 7, 260, 2, 2, 2460, 2462, 7, 249, 2, 2, 2461, 2458, 3, 2, 2, 2, 2461, 2462, 3, 2, 2, 2, 2462, 2510, 3, 2, 2, 2, 2463, 2510, 7, 46, 2, 2, 2464, 2510, 7, 43, 2, 2, 2465, 2466, 7, 186, 2, 2, 2466, 2467, 7, 248, 2, 2, 2467, 2468, 5, 310, 156, 2, 2468, 2469, 7, 84, 2, 2, 2469, 2472, 5, 310, 156, 2, 2470, 2471, 7, 80, 2, 2, 2471, 2473, 5, 310, 156, 2, 2472, 2470, 3, 2, 2, 2, 2472, 2473, 3, 2, 2, 2, 2473, 2474, 3, 2, 2, 2, 2474, 2475, 7, 249, 2, 2, 2475, 2510, 3, 2, 2, 2, 2476, 2477, 7, 132, 2, 2, 2477, 2478, 7, 248, 2, 2, 2478, 2481, 5, 310, 156, 2, 2479, 2480, 7, 246, 2, 2, 2480, 2482, 5, 326, 164, 2, 2481, 2479, 3, 2, 2, 2, 2481, 2482, 3, 2, 2, 2, 2482, 2483, 3, 2, 2, 2, 2483, 2484, 7, 249, 2, 2, 2484, 2510, 3, 2, 2, 2, 2485, 2486, 7, 70, 2, 2, 2486, 2487, 7, 248, 2, 2, 2487, 2488, 5, 356, 179, 2, 2488, 2489, 7, 84, 2, 2, 2489, 2490, 5, 310, 156, 2, 2490, 2491, 7, 249, 2, 2, 2491, 2510, 3, 2, 2, 2, 2492, 2493, 7, 248, 2, 2, 2493, 2494, 5, 304, 153, 2, 2494, 2495, 7, 249, 2, 2, 2495, 2510, 3, 2, 2, 2, 2496, 2497, 7, 90, 2, 2, 2497, 2506, 7, 248, 2, 2, 2498, 2503, 5, 352, 177, 2, 2499, 2500, 7, 246, 2, 2, 2500, 2502, 5, 352, 177, 2, 2501, 2499, 3, 2, 2, 2, 2502, 2505, 3, 2, 2, 2, 2503, 2501, 3, 2, 2, 2, 2503, 2504, 3, 2, 2, 2, 2504, 2507, 3, 2, 2, 2, 2505, 2503, 3, 2, 2, 2, 2506, 2498, 3, 2, 2, 2, 2506, 2507, 3, 2, 2, 2, 2507, 2508, 3, 2, 2, 2, 2508, 2510, 7, 249, 2, 2, 2509, 2263, 3, 2, 2, 2, 2509, 2265, 3, 2, 2, 2, 2509, 2266, 3, 2, 2, 2, 2509, 2269, 3, 2, 2, 2, 2509, 2271, 3, 2, 2, 2, 2509, 2272, 3, 2, 2, 2, 2509, 2273, 3, 2, 2, 2, 2509, 2274, 3, 2, 2, 2, 2509, 2275, 3, 2, 2, 2, 2509, 2276, 3, 2, 2, 2, 2509, 2283, 3, 2, 2, 2, 2509, 2302, 3, 2, 2, 2, 2509, 2314, 3, 2, 2, 2, 2509, 2324, 3, 2, 2, 2, 2509, 2358, 3, 2, 2, 2, 2509, 2362, 3, 2, 2, 2, 2509, 2376, 3, 2, 2, 2, 2509, 2380, 3, 2, 2, 2, 2509, 2385, 3, 2, 2, 2, 2509, 2398, 3, 2, 2, 2, 2509, 2410, 3, 2, 2, 2, 2509, 2417, 3, 2, 2, 2, 2509, 2424, 3, 2, 2, 2, 2509, 2437, 3, 2, 2, 2, 2509, 2438, 3, 2, 2, 2, 2509, 2439, 3, 2, 2, 2, 2509, 2445, 3, 2, 2, 2, 2509, 2451, 3, 2, 2, 2, 2509, 2457, 3, 2, 2, 2, 2509, 2463, 3, 2, 2, 2, 2509, 2464, 3, 2, 2, 2, 2509, 2465, 3, 2, 2, 2, 2509, 2476, 3, 2, 2, 2, 2509, 2485, 3, 2, 2, 2, 2509, 2492, 3, 2, 2, 2, 2509, 2496, 3, 2, 2, 2, 2510, 2521, 3, 2, 2, 2, 2511, 2512, 12, 17, 2, 2, 2512, 2513, 7, 250, 2, 2, 2513, 2514, 5, 310, 156, 2, 2514, 2515, 7, 251, 2, 2, 2515, 2520, 3, 2, 2, 2, 2516, 2517, 12, 15, 2, 2, 2517, 2518, 7, 244, 2, 2, 2518, 2520, 5, 356, 179, 2, 2519, 2511, 3, 2, 2, 2, 2519, 2516, 3, 2, 2, 2, 2520, 2523, 3, 2, 2, 2, 2521, 2519, 3, 2, 2, 2, 2521, 2522, 3, 2, 2, 2, 2522, 313, 3, 2, 2, 2, 2523, 2521, 3, 2, 2, 2, 2524, 2531, 7, 257, 2, 2, 2525, 2528, 7, 258, 2, 2, 2526, 2527, 7, 200, 2, 2, 2527, 2529, 7, 257, 2, 2, 2528, 2526, 3, 2, 2, 2, 2528, 2529, 3, 2, 2, 2, 2529, 2531, 3, 2, 2, 2, 2530, 2524, 3, 2, 2, 2, 2530, 2525, 3, 2, 2, 2, 2531, 315, 3, 2, 2, 2, 2532, 2533, 9, 22, 2, 2, 2533, 317, 3, 2, 2, 2, 2534, 2535, 9, 23, 2, 2, 2535, 319, 3, 2, 2, 2, 2536, 2537, 9, 24, 2, 2, 2537, 321, 3, 2, 2, 2, 2538, 2539, 7, 260, 2, 2, 2539, 2553, 5, 324, 163, 2, 2540, 2541, 7, 248, 2, 2, 2541, 2542, 7, 260, 2, 2, 2542, 2543, 7, 249, 2, 2, 2543, 2553, 5, 324, 163, 2, 2544, 2545, 7, 103, 2, 2, 2545, 2546, 7, 260, 2, 2, 2546, 2553, 5, 324, 163, 2, 2547, 2548, 7, 103, 2, 2, 2548, 2549, 7, 248, 2, 2, 2549, 2550, 7, 260, 2, 2, 2550, 2551, 7, 249, 2, 2, 2551, 2553, 5, 324, 163, 2, 2552, 2538, 3, 2, 2, 2, 2552, 2540, 3, 2, 2, 2, 2552, 2544, 3, 2, 2, 2, 2552, 2547, 3, 2, 2, 2, 2553, 323, 3, 2, 2, 2, 2554, 2555, 9, 25, 2, 2, 2555, 325, 3, 2, 2, 2, 2556, 2557, 9, 26, 2, 2, 2557, 327, 3, 2, 2, 2, 2558, 2559, 8, 165, 1, 2, 2559, 2560, 7, 10, 2, 2, 2560, 2561, 7, 234, 2, 2, 2561, 2562, 5, 328, 165, 2, 2562, 2563, 7, 236, 2, 2, 2563, 2603, 3, 2, 2, 2, 2564, 2565, 7, 122, 2, 2, 2565, 2566, 7, 234, 2, 2, 2566, 2567, 5, 328, 165, 2, 2567, 2568, 7, 246, 2, 2, 2568, 2569, 5, 328, 165, 2, 2569, 2570, 7, 236, 2, 2, 2570, 2603, 3, 2, 2, 2, 2571, 2572, 7, 184, 2, 2, 2572, 2573, 7, 234, 2, 2, 2573, 2574, 5, 356, 179, 2, 2574, 2575, 7, 247, 2, 2, 2575, 2583, 5, 328, 165, 2, 2576, 2577, 7, 246, 2, 2, 2577, 2578, 5, 356, 179, 2, 2578, 2579, 7, 247, 2, 2, 2579, 2580, 5, 328, 165, 2, 2580, 2582, 3, 2, 2, 2, 2581, 2576, 3, 2, 2, 2, 2582, 2585, 3, 2, 2, 2, 2583, 2581, 3, 2, 2, 2, 2583, 2584, 3, 2, 2, 2, 2584, 2586, 3, 2, 2, 2, 2585, 2583, 3, 2, 2, 2, 2586, 2587, 7, 236, 2, 2, 2587, 2603, 3, 2, 2, 2, 2588, 2600, 5, 332, 167, 2, 2589, 2590, 7, 248, 2, 2, 2590, 2595, 5, 330, 166, 2, 2591, 2592, 7, 246, 2, 2, 2592, 2594, 5, 330, 166, 2, 2593, 2591, 3, 2, 2, 2, 2594, 2597, 3, 2, 2, 2, 2595, 2593, 3, 2, 2, 2, 2595, 2596, 3, 2, 2, 2, 2596, 2598, 3, 2, 2, 2, 2597, 2595, 3, 2, 2, 2, 2598, 2599, 7, 249, 2, 2, 2599, 2601, 3, 2, 2, 2, 2600, 2589, 3, 2, 2, 2, 2600, 2601, 3, 2, 2, 2, 2601, 2603, 3, 2, 2, 2, 2602, 2558, 3, 2, 2, 2, 2602, 2564, 3, 2, 2, 2, 2602, 2571, 3, 2, 2, 2, 2602, 2588, 3, 2, 2, 2, 2603, 2608, 3, 2, 2, 2, 2604, 2605, 12, 7, 2, 2, 2605, 2607, 7, 10, 2, 2, 2606, 2604, 3, 2, 2, 2, 2607, 2610, 3, 2, 2, 2, 2608, 2606, 3, 2, 2, 2, 2608, 2609, 3, 2, 2, 2, 2609, 329, 3, 2, 2, 2, 2610, 2608, 3, 2, 2, 2, 2611, 2614, 7, 260, 2, 2, 2612, 2614, 5, 328, 165, 2, 2613, 2611, 3, 2, 2, 2, 2613, 2612, 3, 2, 2, 2, 2614, 331, 3, 2, 2, 2, 2615, 2620, 7, 267, 2, 2, 2616, 2620, 7, 268, 2, 2, 2617, 2620, 7, 269, 2, 2, 2618, 2620, 5, 356, 179, 2, 2619, 2615, 3, 2, 2, 2, 2619, 2616, 3, 2, 2, 2, 2619, 2617, 3, 2, 2, 2, 2619, 2618, 3, 2, 2, 2, 2620, 333, 3, 2, 2, 2, 2621, 2622, 7, 215, 2, 2, 2622, 2623, 5, 304, 153, 2, 2623, 2624, 7, 194, 2, 2, 2624, 2625, 5, 304, 153, 2, 2625, 335, 3, 2, 2, 2, 2626, 2627, 7, 76, 2, 2, 2627, 2628, 7, 248, 2, 2, 2628, 2629, 7, 216, 2, 2, 2629, 2630, 5, 306, 154, 2, 2630, 2631, 7, 249, 2, 2, 2631, 337, 3, 2, 2, 2, 2632, 2633, 7, 144, 2, 2, 2633, 2644, 7, 248, 2, 2, 2634, 2635, 7, 146, 2, 2, 2635, 2636, 7, 28, 2, 2, 2636, 2641, 5, 304, 153, 2, 2637, 2638, 7, 246, 2, 2, 2638, 2640, 5, 304, 153, 2, 2639, 2637, 3, 2, 2, 2, 2640, 2643, 3, 2, 2, 2, 2641, 2639, 3, 2, 2, 2, 2641, 2642, 3, 2, 2, 2, 2642, 2645, 3, 2, 2, 2, 2643, 2641, 3, 2, 2, 2, 2644, 2634, 3, 2, 2, 2, 2644, 2645, 3, 2, 2, 2, 2645, 2656, 3, 2, 2, 2, 2646, 2647, 7, 140, 2, 2, 2647, 2648, 7, 28, 2, 2, 2648, 2653, 5, 262, 132, 2, 2649, 2650, 7, 246, 2, 2, 2650, 2652, 5, 262, 132, 2, 2651, 2649, 3, 2, 2, 2, 2652, 2655, 3, 2, 2, 2, 2653, 2651, 3, 2, 2, 2, 2653, 2654, 3, 2, 2, 2, 2654, 2657, 3, 2, 2, 2, 2655, 2653, 3, 2, 2, 2, 2656, 2646, 3, 2, 2, 2, 2656, 2657, 3, 2, 2, 2, 2657, 2659, 3, 2, 2, 2, 2658, 2660, 5, 340, 171, 2, 2659, 2658, 3, 2, 2, 2, 2659, 2660, 3, 2, 2, 2, 2660, 2661, 3, 2, 2, 2, 2661, 2662, 7, 249, 2, 2, 2662, 339, 3, 2, 2, 2, 2663, 2664, 7, 155, 2, 2, 2664, 2680, 5, 342, 172, 2, 2665, 2666, 7, 170, 2, 2, 2666, 2680, 5, 342, 172, 2, 2667, 2668, 7, 155, 2, 2, 2668, 2669, 7, 17, 2, 2, 2669, 2670, 5, 342, 172, 2, 2670, 2671, 7, 7, 2, 2, 2671, 2672, 5, 342, 172, 2, 2672, 2680, 3, 2, 2, 2, 2673, 2674, 7, 170, 2, 2, 2674, 2675, 7, 17, 2, 2, 2675, 2676, 5, 342, 172, 2, 2676, 2677, 7, 7, 2, 2, 2677, 2678, 5, 342, 172, 2, 2678, 2680, 3, 2, 2, 2, 2679, 2663, 3, 2, 2, 2, 2679, 2665, 3, 2, 2, 2, 2679, 2667, 3, 2, 2, 2, 2679, 2673, 3, 2, 2, 2, 2680, 341, 3, 2, 2, 2, 2681, 2682, 7, 201, 2, 2, 2682, 2691, 7, 150, 2, 2, 2683, 2684, 7, 201, 2, 2, 2684, 2691, 7, 79, 2, 2, 2685, 2686, 7, 41, 2, 2, 2686, 2691, 7, 169, 2, 2, 2687, 2688, 5, 304, 153, 2, 2688, 2689, 9, 27, 2, 2, 2689, 2691, 3, 2, 2, 2, 2690, 2681, 3, 2, 2, 2, 2690, 2683, 3, 2, 2, 2, 2690, 2685, 3, 2, 2, 2, 2690, 2687, 3, 2, 2, 2, 2691, 343, 3, 2, 2, 2, 2692, 2693, 5, 356, 179, 2, 2693, 2694, 7, 244, 2, 2, 2694, 2695, 5, 356, 179, 2, 2695, 2698, 3, 2, 2, 2, 2696, 2698, 5, 356, 179, 2, 2697, 2692, 3, 2, 2, 2, 2697, 2696, 3, 2, 2, 2, 2698, 345, 3, 2, 2, 2, 2699, 2704, 5, 344, 173, 2, 2700, 2701, 7, 246, 2, 2, 2701, 2703, 5, 344, 173, 2, 2702, 2700, 3, 2, 2, 2, 2703, 2706, 3, 2, 2, 2, 2704, 2702, 3, 2, 2, 2, 2704, 2705, 3, 2, 2, 2, 2705, 347, 3, 2, 2, 2, 2706, 2704, 3, 2, 2, 2, 2707, 2721, 7, 4, 2, 2, 2708, 2721, 7, 6, 2, 2, 2709, 2721, 7, 60, 2, 2, 2710, 2721, 7, 39, 2, 2, 2711, 2721, 7, 101, 2, 2, 2712, 2721, 7, 163, 2, 2, 2713, 2718, 7, 175, 2, 2, 2714, 2715, 7, 248, 2, 2, 2715, 2716, 5, 356, 179, 2, 2716, 2717, 7, 249, 2, 2, 2717, 2719, 3, 2, 2, 2, 2718, 2714, 3, 2, 2, 2, 2718, 2719, 3, 2, 2, 2, 2719, 2721, 3, 2, 2, 2, 2720, 2707, 3, 2, 2, 2, 2720, 2708, 3, 2, 2, 2, 2720, 2709, 3, 2, 2, 2, 2720, 2710, 3, 2, 2, 2, 2720, 2711, 3, 2, 2, 2, 2720, 2712, 3, 2, 2, 2, 2720, 2713, 3, 2, 2, 2, 2721, 349, 3, 2, 2, 2, 2722, 2723, 9, 28, 2, 2, 2723, 351, 3, 2, 2, 2, 2724, 2729, 5, 356, 179, 2, 2725, 2726, 7, 244, 2, 2, 2726, 2728, 5, 356, 179, 2, 2727, 2725, 3, 2, 2, 2, 2728, 2731, 3, 2, 2, 2, 2729, 2727, 3, 2, 2, 2, 2729, 2730, 3, 2, 2, 2, 2730, 353, 3, 2, 2, 2, 2731, 2729, 3, 2, 2, 2, 2732, 2733, 7, 167, 2, 2, 2733, 2739, 5, 356, 179, 2, 2734, 2735, 7, 206, 2, 2, 2735, 2739, 5, 356, 179, 2, 2736, 2737, 7, 89, 2, 2, 2737, 2739, 5, 356, 179, 2, 2738, 2732, 3, 2, 2, 2, 2738, 2734, 3, 2, 2, 2, 2738, 2736, 3, 2, 2, 2, 2739, 355, 3, 2, 2, 2, 2740, 2746, 7, 263, 2, 2, 2741, 2746, 7, 257, 2, 2, 2742, 2746, 5, 360, 181, 2, 2743, 2746, 7, 266, 2, 2, 2744, 2746, 7, 264, 2, 2, 2745, 2740, 3, 2, 2, 2, 2745, 2741, 3, 2, 2, 2, 2745, 2742, 3, 2, 2, 2, 2745, 2743, 3, 2, 2, 2, 2745, 2744, 3, 2, 2, 2, 2746, 357, 3, 2, 2, 2, 2747, 2749, 7, 239, 2, 2, 2748, 2747, 3, 2, 2, 2, 2748, 2749, 3, 2, 2, 2, 2749, 2750, 3, 2, 2, 2, 2750, 2760, 7, 261, 2, 2, 2751, 2753, 7, 239, 2, 2, 2752, 2751, 3, 2, 2, 2, 2752, 2753, 3, 2, 2, 2, 2753, 2754, 3, 2, 2, 2, 2754, 2760, 7, 262, 2, 2, 2755, 2757, 7, 239, 2, 2, 2756, 2755, 3, 2, 2, 2, 2756, 2757, 3, 2, 2, 2, 2757, 2758, 3, 2, 2, 2, 2758, 2760, 7, 260, 2, 2, 2759, 2748, 3, 2, 2, 2, 2759, 2752, 3, 2, 2, 2, 2759, 2756, 3, 2, 2, 2, 2760, 359, 3, 2, 2, 2, 2761, 2762, 9, 29, 2, 2, 2762, 361, 3, 2, 2, 2, 352, 364, 368, 395, 408, 412, 416, 425, 430, 434, 440, 442, 447, 451, 455, 462, 467, 473, 477, 486, 493, 497, 502, 504, 509, 513, 520, 524, 529, 533, 537, 541, 549, 554, 558, 566, 570, 579, 582, 585, 591, 598, 609, 614, 619, 624, 629, 638, 641, 644, 648, 674, 700, 709, 719, 722, 736, 754, 756, 765, 776, 785, 792, 796, 803, 809, 812, 817, 824, 838, 851, 856, 861, 867, 903, 906, 912, 915, 921, 927, 939, 941, 949, 957, 962, 966, 971, 978, 982, 986, 992, 996, 1000, 1009, 1012, 1015, 1023, 1037, 1044, 1057, 1063, 1068, 1071, 1074, 1079, 1083, 1092, 1097, 1103, 1107, 1112, 1117, 1120, 1128, 1131, 1135, 1147, 1150, 1154, 1159, 1163, 1179, 1184, 1191, 1194, 1200, 1203, 1210, 1213, 1217, 1222, 1225, 1232, 1235, 1259, 1273, 1277, 1281, 1301, 1303, 1305, 1314, 1316, 1325, 1327, 1336, 1338, 1343, 1352, 1361, 1370, 1381, 1387, 1392, 1395, 1408, 1418, 1422, 1427, 1438, 1443, 1476, 1484, 1493, 1498, 1502, 1507, 1512, 1517, 1521, 1530, 1533, 1537, 1544, 1555, 1561, 1565, 1571, 1581, 1588, 1593, 1598, 1603, 1609, 1612, 1621, 1624, 1627, 1633, 1643, 1646, 1650, 1654, 1660, 1666, 1669, 1675, 1681, 1684, 1687, 1691, 1701, 1712, 1717, 1720, 1724, 1731, 1741, 1753, 1759, 1761, 1770, 1773, 1780, 1790, 1796, 1804, 1815, 1825, 1836, 1838, 1844, 1849, 1859, 1862, 1868, 1870, 1878, 1884, 1887, 1889, 1901, 1908, 1912, 1916, 1920, 1923, 1930, 1939, 1942, 1946, 1951, 1955, 1958, 1965, 1976, 1979, 1983, 1987, 1996, 1999, 2006, 2020, 2024, 2028, 2032, 2036, 2040, 2044, 2048, 2058, 2069, 2074, 2087, 2089, 2095, 2099, 2101, 2109, 2120, 2127, 2132, 2145, 2151, 2159, 2166, 2170, 2178, 2180, 2191, 2199, 2208, 2214, 2219, 2225, 2231, 2236, 2241, 2247, 2258, 2260, 2287, 2293, 2297, 2309, 2319, 2322, 2327, 2334, 2337, 2346, 2349, 2353, 2356, 2368, 2371, 2390, 2394, 2402, 2406, 2431, 2434, 2443, 2449, 2455, 2461, 2472, 2481, 2503, 2506, 2509, 2519, 2521, 2528, 2530, 2552, 2583, 2595, 2600, 2602, 2608, 2613, 2619, 2641, 2644, 2653, 2656, 2659, 2679, 2690, 2697, 2704, 2718, 2720, 2729, 2738, 2745, 2748, 2752, 2756, 2759] \ No newline at end of file diff --git a/src/lib/impala/ImpalaSqlParser.tokens b/src/lib/impala/ImpalaSqlParser.tokens new file mode 100644 index 0000000..49c0108 --- /dev/null +++ b/src/lib/impala/ImpalaSqlParser.tokens @@ -0,0 +1,523 @@ +KW_ADD=1 +KW_ALL=2 +KW_ANALYTIC=3 +KW_ALTER=4 +KW_AND=5 +KW_ANY=6 +KW_ANTI=7 +KW_ARRAY=8 +KW_AS=9 +KW_ASC=10 +KW_AT=11 +KW_AGGREGATE=12 +KW_AUTHORIZATION=13 +KW_BERNOULLI=14 +KW_BETWEEN=15 +KW_BLOCK_SIZE=16 +KW_PARTITIONED=17 +KW_PREPARE_FN=18 +KW_EXTERNAL=19 +KW_CLOSEFN=20 +KW_SORT=21 +KW_PURGE=22 +KW_STORED=23 +KW_LOCATION=24 +KW_TBLPROPERTIES=25 +KW_BY=26 +KW_CASCADE=27 +KW_CASE=28 +KW_CAST=29 +KW_CACHED=30 +KW_CHANGE=31 +KW_COLUMN=32 +KW_COLUMNS=33 +KW_COMMENT=34 +KW_COMPRESSION=35 +KW_COMPUTE=36 +KW_CREATE=37 +KW_CROSS=38 +KW_CURRENT=39 +KW_CURRENT_DATE=40 +KW_CURRENT_PATH=41 +KW_CURRENT_TIME=42 +KW_CURRENT_TIMESTAMP=43 +KW_CURRENT_USER=44 +KW_DATA=45 +KW_DATABASE=46 +KW_DATABASES=47 +KW_DAY=48 +KW_DAYS=49 +KW_DELETE=50 +KW_DEFAULT=51 +KW_DELIMITED=52 +KW_DISABLE=53 +KW_UPDATE=54 +KW_DESC=55 +KW_DESCRIBE=56 +KW_DISTINCT=57 +KW_DROP=58 +KW_ELSE=59 +KW_ENCODING=60 +KW_END=61 +KW_ESCAPE=62 +KW_ESCAPED=63 +KW_EXCEPT=64 +KW_EXCLUDING=65 +KW_EXISTS=66 +KW_EXPLAIN=67 +KW_EXTRACT=68 +KW_EXTENDED=69 +KW_FALSE=70 +KW_FIELDS=71 +KW_FILEFORMAT=72 +KW_FILES=73 +KW_FILTER=74 +KW_FIRST=75 +KW_FINALIZE_FN=76 +KW_FOLLOWING=77 +KW_FOR=78 +KW_FORMAT=79 +KW_FORMATTED=80 +KW_FOREIGN=81 +KW_FROM=82 +KW_FULL=83 +KW_FUNCTION=84 +KW_FUNCTIONS=85 +KW_GRANT=86 +KW_GROUP=87 +KW_GROUPING=88 +KW_HASH=89 +KW_HAVING=90 +KW_HOUR=91 +KW_HOURS=92 +KW_IF=93 +KW_IN=94 +KW_INCLUDING=95 +KW_INCREMENTAL=96 +KW_INNER=97 +KW_INPATH=98 +KW_INSERT=99 +KW_INTERSECT=100 +KW_INTERVAL=101 +KW_INTERMEDIATE=102 +KW_INTO=103 +KW_INIT_FN=104 +KW_INVALIDATE=105 +KW_IS=106 +KW_JOIN=107 +KW_KEY=108 +KW_KUDU=109 +KW_LAST=110 +KW_LATERAL=111 +KW_LEFT=112 +KW_LIKE=113 +KW_LIMIT=114 +KW_LINES=115 +KW_LOAD=116 +KW_LOCALTIME=117 +KW_LOCALTIMESTAMP=118 +KW_METADATA=119 +KW_MAP=120 +KW_MINUTE=121 +KW_MINUTES=122 +KW_MONTH=123 +KW_MONTHS=124 +KW_MERGE_FN=125 +KW_NFC=126 +KW_NFD=127 +KW_NFKC=128 +KW_NFKD=129 +KW_NORMALIZE=130 +KW_NOT=131 +KW_NULL=132 +KW_NULLS=133 +KW_OFFSET=134 +KW_ON=135 +KW_OPTION=136 +KW_OR=137 +KW_ORDER=138 +KW_ORDINALITY=139 +KW_OUTER=140 +KW_OWNER=141 +KW_OVER=142 +KW_OVERWRITE=143 +KW_PARTITION=144 +KW_PARTITIONS=145 +KW_PARQUET=146 +KW_POSITION=147 +KW_PRECEDING=148 +KW_PRIMARY=149 +KW_REPLICATION=150 +KW_PRIVILEGES=151 +KW_PROPERTIES=152 +KW_RANGE=153 +KW_RECOVER=154 +KW_RENAME=155 +KW_REPEATABLE=156 +KW_REPLACE=157 +KW_RESTRICT=158 +KW_RETURNS=159 +KW_REVOKE=160 +KW_REFRESH=161 +KW_REGEXP=162 +KW_RLIKE=163 +KW_RIGHT=164 +KW_ROLE=165 +KW_ROLES=166 +KW_ROW=167 +KW_ROWS=168 +KW_SCHEMA=169 +KW_SCHEMAS=170 +KW_SECOND=171 +KW_SECONDS=172 +KW_SELECT=173 +KW_SERDEPROPERTIES=174 +KW_SET=175 +KW_SEMI=176 +KW_SERVER=177 +KW_SHOW=178 +KW_SHUTDOWN=179 +KW_SOME=180 +KW_STATS=181 +KW_STRUCT=182 +KW_STRAIGHT_JOIN=183 +KW_SUBSTRING=184 +KW_SYSTEM=185 +KW_SYMBOL=186 +KW_SERIALIZE_FN=187 +KW_TABLE=188 +KW_TABLES=189 +KW_TABLESAMPLE=190 +KW_TERMINATED=191 +KW_THEN=192 +KW_TO=193 +KW_TRUE=194 +KW_TRY_CAST=195 +KW_TRUNCATE=196 +KW_UNCACHED=197 +KW_UESCAPE=198 +KW_UNBOUNDED=199 +KW_UNION=200 +KW_UNNEST=201 +KW_UNSET=202 +KW_USE=203 +KW_USER=204 +KW_USING=205 +KW_UPDATE_FN=206 +KW_UPSERT=207 +KW_URI=208 +KW_VALUE=209 +KW_VALUES=210 +KW_VIEW=211 +KW_VIEWS=212 +KW_WHEN=213 +KW_WHERE=214 +KW_WITH=215 +KW_YEAR=216 +KW_YEARS=217 +KW_TEXTFILE=218 +KW_ORC=219 +KW_AVRO=220 +KW_SEQUENCEFILE=221 +KW_RCFILE=222 +KW_REFERENCES=223 +KW_NOVALIDATE=224 +KW_RELY=225 +STATS_NUMDVS=226 +STATS_NUMNULLS=227 +STATS_AVGSIZE=228 +STATS_MAXSIZE=229 +EQ=230 +NEQ=231 +LT=232 +LTE=233 +GT=234 +GTE=235 +PLUS=236 +MINUS=237 +ASTERISK=238 +SLASH=239 +PERCENT=240 +CONCAT=241 +DOT=242 +SEMICOLON=243 +COMMA=244 +COLON=245 +LPAREN=246 +RPAREN=247 +LSQUARE=248 +RSQUARE=249 +LCURLY=250 +RCURLY=251 +BITWISEOR=252 +QUESTION=253 +RIGHT_ARROW=254 +STRING=255 +UNICODE_STRING=256 +BINARY_LITERAL=257 +INTEGER_VALUE=258 +DECIMAL_VALUE=259 +DOUBLE_VALUE=260 +IDENTIFIER=261 +DIGIT_IDENTIFIER=262 +QUOTED_IDENTIFIER=263 +BACKQUOTED_IDENTIFIER=264 +TIME_WITH_TIME_ZONE=265 +TIMESTAMP_WITH_TIME_ZONE=266 +DOUBLE_PRECISION=267 +SIMPLE_COMMENT=268 +BRACKETED_COMMENT=269 +WS=270 +'ADD'=1 +'ALL'=2 +'ANALYTIC'=3 +'ALTER'=4 +'AND'=5 +'ANY'=6 +'ANTI'=7 +'ARRAY'=8 +'AS'=9 +'ASC'=10 +'AT'=11 +'AGGREGATE'=12 +'AUTHORIZATION'=13 +'BERNOULLI'=14 +'BETWEEN'=15 +'BLOCK_SIZE'=16 +'PARTITIONED'=17 +'PREPARE_FN'=18 +'EXTERNAL'=19 +'CLOSEFN'=20 +'SORT'=21 +'PURGE'=22 +'STORED'=23 +'LOCATION'=24 +'TBLPROPERTIES'=25 +'BY'=26 +'CASCADE'=27 +'CASE'=28 +'CAST'=29 +'CACHED'=30 +'CHANGE'=31 +'COLUMN'=32 +'COLUMNS'=33 +'COMMENT'=34 +'COMPRESSION'=35 +'COMPUTE'=36 +'CREATE'=37 +'CROSS'=38 +'CURRENT'=39 +'CURRENT_DATE'=40 +'CURRENT_PATH'=41 +'CURRENT_TIME'=42 +'CURRENT_TIMESTAMP'=43 +'CURRENT_USER'=44 +'DATA'=45 +'DATABASE'=46 +'DATABASES'=47 +'DAY'=48 +'DAYS'=49 +'DELETE'=50 +'DEFAULT'=51 +'DELIMITED'=52 +'DISABLE'=53 +'UPDATE'=54 +'DESC'=55 +'DESCRIBE'=56 +'DISTINCT'=57 +'DROP'=58 +'ELSE'=59 +'ENCODING'=60 +'END'=61 +'ESCAPE'=62 +'ESCAPED'=63 +'EXCEPT'=64 +'EXCLUDING'=65 +'EXISTS'=66 +'EXPLAIN'=67 +'EXTRACT'=68 +'EXTENDED'=69 +'FALSE'=70 +'FIELDS'=71 +'FILEFORMAT'=72 +'FILES'=73 +'FILTER'=74 +'FIRST'=75 +'FINALIZE_FN'=76 +'FOLLOWING'=77 +'FOR'=78 +'FORMAT'=79 +'FORMATTED'=80 +'FOREIGN'=81 +'FROM'=82 +'FULL'=83 +'FUNCTION'=84 +'FUNCTIONS'=85 +'GRANT'=86 +'GROUP'=87 +'GROUPING'=88 +'HASH'=89 +'HAVING'=90 +'HOUR'=91 +'HOURS'=92 +'IF'=93 +'IN'=94 +'INCLUDING'=95 +'INCREMENTAL'=96 +'INNER'=97 +'INPATH'=98 +'INSERT'=99 +'INTERSECT'=100 +'INTERVAL'=101 +'INTERMEDIATE'=102 +'INTO'=103 +'INIT_FN'=104 +'INVALIDATE'=105 +'IS'=106 +'JOIN'=107 +'KEY'=108 +'KUDU'=109 +'LAST'=110 +'LATERAL'=111 +'LEFT'=112 +'LIKE'=113 +'LIMIT'=114 +'LINES'=115 +'LOAD'=116 +'LOCALTIME'=117 +'LOCALTIMESTAMP'=118 +'METADATA'=119 +'MAP'=120 +'MINUTE'=121 +'MINUTES'=122 +'MONTH'=123 +'MONTHS'=124 +'MERGE_FN'=125 +'NFC'=126 +'NFD'=127 +'NFKC'=128 +'NFKD'=129 +'NORMALIZE'=130 +'NOT'=131 +'NULL'=132 +'NULLS'=133 +'OFFSET'=134 +'ON'=135 +'OPTION'=136 +'OR'=137 +'ORDER'=138 +'ORDINALITY'=139 +'OUTER'=140 +'OWNER'=141 +'OVER'=142 +'OVERWRITE'=143 +'PARTITION'=144 +'PARTITIONS'=145 +'PARQUET'=146 +'POSITION'=147 +'PRECEDING'=148 +'PRIMARY'=149 +'REPLICATION'=150 +'PRIVILEGES'=151 +'PROPERTIES'=152 +'RANGE'=153 +'RECOVER'=154 +'RENAME'=155 +'REPEATABLE'=156 +'REPLACE'=157 +'RESTRICT'=158 +'RETURNS'=159 +'REVOKE'=160 +'REFRESH'=161 +'REGEXP'=162 +'RLIKE'=163 +'RIGHT'=164 +'ROLE'=165 +'ROLES'=166 +'ROW'=167 +'ROWS'=168 +'SCHEMA'=169 +'SCHEMAS'=170 +'SECOND'=171 +'SECONDS'=172 +'SELECT'=173 +'SERDEPROPERTIES'=174 +'SET'=175 +'SEMI'=176 +'SERVER'=177 +'SHOW'=178 +'SHUTDOWN'=179 +'SOME'=180 +'STATS'=181 +'STRUCT'=182 +'STRAIGHT_JOIN'=183 +'SUBSTRING'=184 +'SYSTEM'=185 +'SYMBOL'=186 +'SERIALIZE_FN'=187 +'TABLE'=188 +'TABLES'=189 +'TABLESAMPLE'=190 +'TERMINATED '=191 +'THEN'=192 +'TO'=193 +'TRUE'=194 +'TRY_CAST'=195 +'TRUNCATE'=196 +'UNCACHED'=197 +'UESCAPE'=198 +'UNBOUNDED'=199 +'UNION'=200 +'UNNEST'=201 +'UNSET'=202 +'USE'=203 +'USER'=204 +'USING'=205 +'UPDATE_FN'=206 +'UPSERT'=207 +'URI'=208 +'VALUE'=209 +'VALUES'=210 +'VIEW'=211 +'VIEWS'=212 +'WHEN'=213 +'WHERE'=214 +'WITH'=215 +'YEAR'=216 +'YEARS'=217 +'TEXTFILE'=218 +'ORC'=219 +'AVRO'=220 +'SEQUENCEFILE'=221 +'RCFILE'=222 +'REFERENCES'=223 +'NOVALIDATE'=224 +'RELY'=225 +'\'NUMDVS\''=226 +'\'NUMNULLS\''=227 +'\'AVGSIZE\''=228 +'\'MAXSIZE\''=229 +'='=230 +'<'=232 +'<='=233 +'>'=234 +'>='=235 +'+'=236 +'-'=237 +'*'=238 +'/'=239 +'%'=240 +'||'=241 +'.'=242 +';'=243 +','=244 +':'=245 +'('=246 +')'=247 +'['=248 +']'=249 +'{'=250 +'}'=251 +'|'=252 +'?'=253 +'->'=254 diff --git a/src/lib/impala/ImpalaSqlParser.ts b/src/lib/impala/ImpalaSqlParser.ts new file mode 100644 index 0000000..09d4df0 --- /dev/null +++ b/src/lib/impala/ImpalaSqlParser.ts @@ -0,0 +1,25304 @@ +// Generated from /Users/shuangxu/Documents/workspace/dt-sql-parser/src/grammar/impala/ImpalaSqlParser.g4 by ANTLR 4.9.0-SNAPSHOT + + +import { ATN } from "antlr4ts/atn/ATN"; +import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer"; +import { FailedPredicateException } from "antlr4ts/FailedPredicateException"; +import { NotNull } from "antlr4ts/Decorators"; +import { NoViableAltException } from "antlr4ts/NoViableAltException"; +import { Override } from "antlr4ts/Decorators"; +import { Parser } from "antlr4ts/Parser"; +import { ParserRuleContext } from "antlr4ts/ParserRuleContext"; +import { ParserATNSimulator } from "antlr4ts/atn/ParserATNSimulator"; +import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener"; +import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor"; +import { RecognitionException } from "antlr4ts/RecognitionException"; +import { RuleContext } from "antlr4ts/RuleContext"; +//import { RuleVersion } from "antlr4ts/RuleVersion"; +import { TerminalNode } from "antlr4ts/tree/TerminalNode"; +import { Token } from "antlr4ts/Token"; +import { TokenStream } from "antlr4ts/TokenStream"; +import { Vocabulary } from "antlr4ts/Vocabulary"; +import { VocabularyImpl } from "antlr4ts/VocabularyImpl"; + +import * as Utils from "antlr4ts/misc/Utils"; + +import { ImpalaSqlParserListener } from "./ImpalaSqlParserListener"; +import { ImpalaSqlParserVisitor } from "./ImpalaSqlParserVisitor"; + + +export class ImpalaSqlParser extends Parser { + public static readonly KW_ADD = 1; + public static readonly KW_ALL = 2; + public static readonly KW_ANALYTIC = 3; + public static readonly KW_ALTER = 4; + public static readonly KW_AND = 5; + public static readonly KW_ANY = 6; + public static readonly KW_ANTI = 7; + public static readonly KW_ARRAY = 8; + public static readonly KW_AS = 9; + public static readonly KW_ASC = 10; + public static readonly KW_AT = 11; + public static readonly KW_AGGREGATE = 12; + public static readonly KW_AUTHORIZATION = 13; + public static readonly KW_BERNOULLI = 14; + public static readonly KW_BETWEEN = 15; + public static readonly KW_BLOCK_SIZE = 16; + public static readonly KW_PARTITIONED = 17; + public static readonly KW_PREPARE_FN = 18; + public static readonly KW_EXTERNAL = 19; + public static readonly KW_CLOSEFN = 20; + public static readonly KW_SORT = 21; + public static readonly KW_PURGE = 22; + public static readonly KW_STORED = 23; + public static readonly KW_LOCATION = 24; + public static readonly KW_TBLPROPERTIES = 25; + public static readonly KW_BY = 26; + public static readonly KW_CASCADE = 27; + public static readonly KW_CASE = 28; + public static readonly KW_CAST = 29; + public static readonly KW_CACHED = 30; + public static readonly KW_CHANGE = 31; + public static readonly KW_COLUMN = 32; + public static readonly KW_COLUMNS = 33; + public static readonly KW_COMMENT = 34; + public static readonly KW_COMPRESSION = 35; + public static readonly KW_COMPUTE = 36; + public static readonly KW_CREATE = 37; + public static readonly KW_CROSS = 38; + public static readonly KW_CURRENT = 39; + public static readonly KW_CURRENT_DATE = 40; + public static readonly KW_CURRENT_PATH = 41; + public static readonly KW_CURRENT_TIME = 42; + public static readonly KW_CURRENT_TIMESTAMP = 43; + public static readonly KW_CURRENT_USER = 44; + public static readonly KW_DATA = 45; + public static readonly KW_DATABASE = 46; + public static readonly KW_DATABASES = 47; + public static readonly KW_DAY = 48; + public static readonly KW_DAYS = 49; + public static readonly KW_DELETE = 50; + public static readonly KW_DEFAULT = 51; + public static readonly KW_DELIMITED = 52; + public static readonly KW_DISABLE = 53; + public static readonly KW_UPDATE = 54; + public static readonly KW_DESC = 55; + public static readonly KW_DESCRIBE = 56; + public static readonly KW_DISTINCT = 57; + public static readonly KW_DROP = 58; + public static readonly KW_ELSE = 59; + public static readonly KW_ENCODING = 60; + public static readonly KW_END = 61; + public static readonly KW_ESCAPE = 62; + public static readonly KW_ESCAPED = 63; + public static readonly KW_EXCEPT = 64; + public static readonly KW_EXCLUDING = 65; + public static readonly KW_EXISTS = 66; + public static readonly KW_EXPLAIN = 67; + public static readonly KW_EXTRACT = 68; + public static readonly KW_EXTENDED = 69; + public static readonly KW_FALSE = 70; + public static readonly KW_FIELDS = 71; + public static readonly KW_FILEFORMAT = 72; + public static readonly KW_FILES = 73; + public static readonly KW_FILTER = 74; + public static readonly KW_FIRST = 75; + public static readonly KW_FINALIZE_FN = 76; + public static readonly KW_FOLLOWING = 77; + public static readonly KW_FOR = 78; + public static readonly KW_FORMAT = 79; + public static readonly KW_FORMATTED = 80; + public static readonly KW_FOREIGN = 81; + public static readonly KW_FROM = 82; + public static readonly KW_FULL = 83; + public static readonly KW_FUNCTION = 84; + public static readonly KW_FUNCTIONS = 85; + public static readonly KW_GRANT = 86; + public static readonly KW_GROUP = 87; + public static readonly KW_GROUPING = 88; + public static readonly KW_HASH = 89; + public static readonly KW_HAVING = 90; + public static readonly KW_HOUR = 91; + public static readonly KW_HOURS = 92; + public static readonly KW_IF = 93; + public static readonly KW_IN = 94; + public static readonly KW_INCLUDING = 95; + public static readonly KW_INCREMENTAL = 96; + public static readonly KW_INNER = 97; + public static readonly KW_INPATH = 98; + public static readonly KW_INSERT = 99; + public static readonly KW_INTERSECT = 100; + public static readonly KW_INTERVAL = 101; + public static readonly KW_INTERMEDIATE = 102; + public static readonly KW_INTO = 103; + public static readonly KW_INIT_FN = 104; + public static readonly KW_INVALIDATE = 105; + public static readonly KW_IS = 106; + public static readonly KW_JOIN = 107; + public static readonly KW_KEY = 108; + public static readonly KW_KUDU = 109; + public static readonly KW_LAST = 110; + public static readonly KW_LATERAL = 111; + public static readonly KW_LEFT = 112; + public static readonly KW_LIKE = 113; + public static readonly KW_LIMIT = 114; + public static readonly KW_LINES = 115; + public static readonly KW_LOAD = 116; + public static readonly KW_LOCALTIME = 117; + public static readonly KW_LOCALTIMESTAMP = 118; + public static readonly KW_METADATA = 119; + public static readonly KW_MAP = 120; + public static readonly KW_MINUTE = 121; + public static readonly KW_MINUTES = 122; + public static readonly KW_MONTH = 123; + public static readonly KW_MONTHS = 124; + public static readonly KW_MERGE_FN = 125; + public static readonly KW_NFC = 126; + public static readonly KW_NFD = 127; + public static readonly KW_NFKC = 128; + public static readonly KW_NFKD = 129; + public static readonly KW_NORMALIZE = 130; + public static readonly KW_NOT = 131; + public static readonly KW_NULL = 132; + public static readonly KW_NULLS = 133; + public static readonly KW_OFFSET = 134; + public static readonly KW_ON = 135; + public static readonly KW_OPTION = 136; + public static readonly KW_OR = 137; + public static readonly KW_ORDER = 138; + public static readonly KW_ORDINALITY = 139; + public static readonly KW_OUTER = 140; + public static readonly KW_OWNER = 141; + public static readonly KW_OVER = 142; + public static readonly KW_OVERWRITE = 143; + public static readonly KW_PARTITION = 144; + public static readonly KW_PARTITIONS = 145; + public static readonly KW_PARQUET = 146; + public static readonly KW_POSITION = 147; + public static readonly KW_PRECEDING = 148; + public static readonly KW_PRIMARY = 149; + public static readonly KW_REPLICATION = 150; + public static readonly KW_PRIVILEGES = 151; + public static readonly KW_PROPERTIES = 152; + public static readonly KW_RANGE = 153; + public static readonly KW_RECOVER = 154; + public static readonly KW_RENAME = 155; + public static readonly KW_REPEATABLE = 156; + public static readonly KW_REPLACE = 157; + public static readonly KW_RESTRICT = 158; + public static readonly KW_RETURNS = 159; + public static readonly KW_REVOKE = 160; + public static readonly KW_REFRESH = 161; + public static readonly KW_REGEXP = 162; + public static readonly KW_RLIKE = 163; + public static readonly KW_RIGHT = 164; + public static readonly KW_ROLE = 165; + public static readonly KW_ROLES = 166; + public static readonly KW_ROW = 167; + public static readonly KW_ROWS = 168; + public static readonly KW_SCHEMA = 169; + public static readonly KW_SCHEMAS = 170; + public static readonly KW_SECOND = 171; + public static readonly KW_SECONDS = 172; + public static readonly KW_SELECT = 173; + public static readonly KW_SERDEPROPERTIES = 174; + public static readonly KW_SET = 175; + public static readonly KW_SEMI = 176; + public static readonly KW_SERVER = 177; + public static readonly KW_SHOW = 178; + public static readonly KW_SHUTDOWN = 179; + public static readonly KW_SOME = 180; + public static readonly KW_STATS = 181; + public static readonly KW_STRUCT = 182; + public static readonly KW_STRAIGHT_JOIN = 183; + public static readonly KW_SUBSTRING = 184; + public static readonly KW_SYSTEM = 185; + public static readonly KW_SYMBOL = 186; + public static readonly KW_SERIALIZE_FN = 187; + public static readonly KW_TABLE = 188; + public static readonly KW_TABLES = 189; + public static readonly KW_TABLESAMPLE = 190; + public static readonly KW_TERMINATED = 191; + public static readonly KW_THEN = 192; + public static readonly KW_TO = 193; + public static readonly KW_TRUE = 194; + public static readonly KW_TRY_CAST = 195; + public static readonly KW_TRUNCATE = 196; + public static readonly KW_UNCACHED = 197; + public static readonly KW_UESCAPE = 198; + public static readonly KW_UNBOUNDED = 199; + public static readonly KW_UNION = 200; + public static readonly KW_UNNEST = 201; + public static readonly KW_UNSET = 202; + public static readonly KW_USE = 203; + public static readonly KW_USER = 204; + public static readonly KW_USING = 205; + public static readonly KW_UPDATE_FN = 206; + public static readonly KW_UPSERT = 207; + public static readonly KW_URI = 208; + public static readonly KW_VALUE = 209; + public static readonly KW_VALUES = 210; + public static readonly KW_VIEW = 211; + public static readonly KW_VIEWS = 212; + public static readonly KW_WHEN = 213; + public static readonly KW_WHERE = 214; + public static readonly KW_WITH = 215; + public static readonly KW_YEAR = 216; + public static readonly KW_YEARS = 217; + public static readonly KW_TEXTFILE = 218; + public static readonly KW_ORC = 219; + public static readonly KW_AVRO = 220; + public static readonly KW_SEQUENCEFILE = 221; + public static readonly KW_RCFILE = 222; + public static readonly KW_REFERENCES = 223; + public static readonly KW_NOVALIDATE = 224; + public static readonly KW_RELY = 225; + public static readonly STATS_NUMDVS = 226; + public static readonly STATS_NUMNULLS = 227; + public static readonly STATS_AVGSIZE = 228; + public static readonly STATS_MAXSIZE = 229; + public static readonly EQ = 230; + public static readonly NEQ = 231; + public static readonly LT = 232; + public static readonly LTE = 233; + public static readonly GT = 234; + public static readonly GTE = 235; + public static readonly PLUS = 236; + public static readonly MINUS = 237; + public static readonly ASTERISK = 238; + public static readonly SLASH = 239; + public static readonly PERCENT = 240; + public static readonly CONCAT = 241; + public static readonly DOT = 242; + public static readonly SEMICOLON = 243; + public static readonly COMMA = 244; + public static readonly COLON = 245; + public static readonly LPAREN = 246; + public static readonly RPAREN = 247; + public static readonly LSQUARE = 248; + public static readonly RSQUARE = 249; + public static readonly LCURLY = 250; + public static readonly RCURLY = 251; + public static readonly BITWISEOR = 252; + public static readonly QUESTION = 253; + public static readonly RIGHT_ARROW = 254; + public static readonly STRING = 255; + public static readonly UNICODE_STRING = 256; + public static readonly BINARY_LITERAL = 257; + public static readonly INTEGER_VALUE = 258; + public static readonly DECIMAL_VALUE = 259; + public static readonly DOUBLE_VALUE = 260; + public static readonly IDENTIFIER = 261; + public static readonly DIGIT_IDENTIFIER = 262; + public static readonly QUOTED_IDENTIFIER = 263; + public static readonly BACKQUOTED_IDENTIFIER = 264; + public static readonly TIME_WITH_TIME_ZONE = 265; + public static readonly TIMESTAMP_WITH_TIME_ZONE = 266; + public static readonly DOUBLE_PRECISION = 267; + public static readonly SIMPLE_COMMENT = 268; + public static readonly BRACKETED_COMMENT = 269; + public static readonly WS = 270; + public static readonly RULE_program = 0; + public static readonly RULE_statement = 1; + public static readonly RULE_useStatement = 2; + public static readonly RULE_createStatement = 3; + public static readonly RULE_createTableSelect = 4; + public static readonly RULE_createTableLike = 5; + public static readonly RULE_createKuduTableAsSelect = 6; + public static readonly RULE_createView = 7; + public static readonly RULE_createSchema = 8; + public static readonly RULE_createRole = 9; + public static readonly RULE_createAggregateFunction = 10; + public static readonly RULE_createFunction = 11; + public static readonly RULE_alterStatement = 12; + public static readonly RULE_alterDatabase = 13; + public static readonly RULE_alterStatsKey = 14; + public static readonly RULE_alterPartitionCache = 15; + public static readonly RULE_changeColumnDefine = 16; + public static readonly RULE_alterDropSingleColumn = 17; + public static readonly RULE_alterTableOwner = 18; + public static readonly RULE_replaceOrAddColumns = 19; + public static readonly RULE_addSingleColumn = 20; + public static readonly RULE_alterTableNonKuduOrKuduOnly = 21; + public static readonly RULE_addPartitionByRangeOrValue = 22; + public static readonly RULE_alterFormat = 23; + public static readonly RULE_recoverPartitions = 24; + public static readonly RULE_dropPartitionByRangeOrValue = 25; + public static readonly RULE_alterView = 26; + public static readonly RULE_renameView = 27; + public static readonly RULE_alterViewOwner = 28; + public static readonly RULE_renameTable = 29; + public static readonly RULE_alterUnSetOrSetViewTblproperties = 30; + public static readonly RULE_truncateTableStatement = 31; + public static readonly RULE_describeStatement = 32; + public static readonly RULE_computeStatement = 33; + public static readonly RULE_computeStats = 34; + public static readonly RULE_computeIncrementalStats = 35; + public static readonly RULE_dropStatement = 36; + public static readonly RULE_dropSchema = 37; + public static readonly RULE_dropView = 38; + public static readonly RULE_dropTable = 39; + public static readonly RULE_dropIncrementalStats = 40; + public static readonly RULE_dropFunction = 41; + public static readonly RULE_dropRole = 42; + public static readonly RULE_grantStatement = 43; + public static readonly RULE_grantRole = 44; + public static readonly RULE_grant = 45; + public static readonly RULE_revokeStatement = 46; + public static readonly RULE_revokeRole = 47; + public static readonly RULE_revoke = 48; + public static readonly RULE_insertStatement = 49; + public static readonly RULE_deleteStatement = 50; + public static readonly RULE_delete = 51; + public static readonly RULE_deleteTableRef = 52; + public static readonly RULE_updateStatement = 53; + public static readonly RULE_upsertStatement = 54; + public static readonly RULE_showStatement = 55; + public static readonly RULE_showSchemas = 56; + public static readonly RULE_showTables = 57; + public static readonly RULE_showFunctions = 58; + public static readonly RULE_showCreateTable = 59; + public static readonly RULE_showCreateView = 60; + public static readonly RULE_showTableStats = 61; + public static readonly RULE_showColumnStats = 62; + public static readonly RULE_showPartitions = 63; + public static readonly RULE_showFiles = 64; + public static readonly RULE_showRoles = 65; + public static readonly RULE_showRoleGrant = 66; + public static readonly RULE_showGrants = 67; + public static readonly RULE_showDatabaseGrant = 68; + public static readonly RULE_showTableGrant = 69; + public static readonly RULE_showColumnGrant = 70; + public static readonly RULE_addCommentStatement = 71; + public static readonly RULE_addDatabaseComments = 72; + public static readonly RULE_addTableComments = 73; + public static readonly RULE_addColumnComments = 74; + public static readonly RULE_explainStatement = 75; + public static readonly RULE_setStatement = 76; + public static readonly RULE_shutdownStatement = 77; + public static readonly RULE_invalidateMetaStatement = 78; + public static readonly RULE_loadDataStatement = 79; + public static readonly RULE_refreshStatement = 80; + public static readonly RULE_refreshMeta = 81; + public static readonly RULE_refreshAuth = 82; + public static readonly RULE_refreshFunction = 83; + public static readonly RULE_ifExists = 84; + public static readonly RULE_ifNotExists = 85; + public static readonly RULE_tableNameCreate = 86; + public static readonly RULE_databaseNameCreate = 87; + public static readonly RULE_viewNameCreate = 88; + public static readonly RULE_functionNameCreate = 89; + public static readonly RULE_columnNamePathCreate = 90; + public static readonly RULE_databaseNamePath = 91; + public static readonly RULE_tableNamePath = 92; + public static readonly RULE_viewNamePath = 93; + public static readonly RULE_functionNamePath = 94; + public static readonly RULE_columnNamePath = 95; + public static readonly RULE_tableOrViewPath = 96; + public static readonly RULE_createCommonItem = 97; + public static readonly RULE_assignmentList = 98; + public static readonly RULE_assignmentItem = 99; + public static readonly RULE_viewColumns = 100; + public static readonly RULE_queryStatement = 101; + public static readonly RULE_with = 102; + public static readonly RULE_constraintSpecification = 103; + public static readonly RULE_foreignKeySpecification = 104; + public static readonly RULE_columnDefinition = 105; + public static readonly RULE_kuduTableElement = 106; + public static readonly RULE_kuduColumnDefinition = 107; + public static readonly RULE_columnSpecWithKudu = 108; + public static readonly RULE_createColumnSpecWithKudu = 109; + public static readonly RULE_kuduAttributes = 110; + public static readonly RULE_kuduStorageAttr = 111; + public static readonly RULE_statsKey = 112; + public static readonly RULE_fileFormat = 113; + public static readonly RULE_kuduPartitionClause = 114; + public static readonly RULE_hashClause = 115; + public static readonly RULE_rangeClause = 116; + public static readonly RULE_kuduPartitionSpec = 117; + public static readonly RULE_cacheSpec = 118; + public static readonly RULE_rangeOperator = 119; + public static readonly RULE_partitionCol = 120; + public static readonly RULE_likeClause = 121; + public static readonly RULE_properties = 122; + public static readonly RULE_partitionedBy = 123; + public static readonly RULE_sortedBy = 124; + public static readonly RULE_rowFormat = 125; + public static readonly RULE_property = 126; + public static readonly RULE_queryNoWith = 127; + public static readonly RULE_queryTerm = 128; + public static readonly RULE_queryPrimary = 129; + public static readonly RULE_sortItem = 130; + public static readonly RULE_querySpecification = 131; + public static readonly RULE_groupBy = 132; + public static readonly RULE_groupingElement = 133; + public static readonly RULE_groupingSet = 134; + public static readonly RULE_namedQuery = 135; + public static readonly RULE_setQuantifier = 136; + public static readonly RULE_selectItem = 137; + public static readonly RULE_relation = 138; + public static readonly RULE_joinType = 139; + public static readonly RULE_joinCriteria = 140; + public static readonly RULE_sampledRelation = 141; + public static readonly RULE_sampleType = 142; + public static readonly RULE_aliasedRelation = 143; + public static readonly RULE_columnAliases = 144; + public static readonly RULE_createColumnAliases = 145; + public static readonly RULE_relationPrimary = 146; + public static readonly RULE_subQueryRelation = 147; + public static readonly RULE_unnest = 148; + public static readonly RULE_parenthesizedRelation = 149; + public static readonly RULE_columnItem = 150; + public static readonly RULE_expression = 151; + public static readonly RULE_booleanExpression = 152; + public static readonly RULE_predicate = 153; + public static readonly RULE_valueExpression = 154; + public static readonly RULE_primaryExpression = 155; + public static readonly RULE_stringLiteral = 156; + public static readonly RULE_comparisonOperator = 157; + public static readonly RULE_comparisonQuantifier = 158; + public static readonly RULE_booleanValue = 159; + public static readonly RULE_interval = 160; + public static readonly RULE_intervalField = 161; + public static readonly RULE_normalForm = 162; + public static readonly RULE_type = 163; + public static readonly RULE_typeParameter = 164; + public static readonly RULE_baseType = 165; + public static readonly RULE_whenClause = 166; + public static readonly RULE_filter = 167; + public static readonly RULE_over = 168; + public static readonly RULE_windowFrame = 169; + public static readonly RULE_frameBound = 170; + public static readonly RULE_pathElement = 171; + public static readonly RULE_pathSpecification = 172; + public static readonly RULE_privilege = 173; + public static readonly RULE_objectType = 174; + public static readonly RULE_qualifiedName = 175; + public static readonly RULE_principal = 176; + public static readonly RULE_identifier = 177; + public static readonly RULE_number = 178; + public static readonly RULE_nonReserved = 179; + // tslint:disable:no-trailing-whitespace + public static readonly ruleNames: string[] = [ + "program", "statement", "useStatement", "createStatement", "createTableSelect", + "createTableLike", "createKuduTableAsSelect", "createView", "createSchema", + "createRole", "createAggregateFunction", "createFunction", "alterStatement", + "alterDatabase", "alterStatsKey", "alterPartitionCache", "changeColumnDefine", + "alterDropSingleColumn", "alterTableOwner", "replaceOrAddColumns", "addSingleColumn", + "alterTableNonKuduOrKuduOnly", "addPartitionByRangeOrValue", "alterFormat", + "recoverPartitions", "dropPartitionByRangeOrValue", "alterView", "renameView", + "alterViewOwner", "renameTable", "alterUnSetOrSetViewTblproperties", "truncateTableStatement", + "describeStatement", "computeStatement", "computeStats", "computeIncrementalStats", + "dropStatement", "dropSchema", "dropView", "dropTable", "dropIncrementalStats", + "dropFunction", "dropRole", "grantStatement", "grantRole", "grant", "revokeStatement", + "revokeRole", "revoke", "insertStatement", "deleteStatement", "delete", + "deleteTableRef", "updateStatement", "upsertStatement", "showStatement", + "showSchemas", "showTables", "showFunctions", "showCreateTable", "showCreateView", + "showTableStats", "showColumnStats", "showPartitions", "showFiles", "showRoles", + "showRoleGrant", "showGrants", "showDatabaseGrant", "showTableGrant", + "showColumnGrant", "addCommentStatement", "addDatabaseComments", "addTableComments", + "addColumnComments", "explainStatement", "setStatement", "shutdownStatement", + "invalidateMetaStatement", "loadDataStatement", "refreshStatement", "refreshMeta", + "refreshAuth", "refreshFunction", "ifExists", "ifNotExists", "tableNameCreate", + "databaseNameCreate", "viewNameCreate", "functionNameCreate", "columnNamePathCreate", + "databaseNamePath", "tableNamePath", "viewNamePath", "functionNamePath", + "columnNamePath", "tableOrViewPath", "createCommonItem", "assignmentList", + "assignmentItem", "viewColumns", "queryStatement", "with", "constraintSpecification", + "foreignKeySpecification", "columnDefinition", "kuduTableElement", "kuduColumnDefinition", + "columnSpecWithKudu", "createColumnSpecWithKudu", "kuduAttributes", "kuduStorageAttr", + "statsKey", "fileFormat", "kuduPartitionClause", "hashClause", "rangeClause", + "kuduPartitionSpec", "cacheSpec", "rangeOperator", "partitionCol", "likeClause", + "properties", "partitionedBy", "sortedBy", "rowFormat", "property", "queryNoWith", + "queryTerm", "queryPrimary", "sortItem", "querySpecification", "groupBy", + "groupingElement", "groupingSet", "namedQuery", "setQuantifier", "selectItem", + "relation", "joinType", "joinCriteria", "sampledRelation", "sampleType", + "aliasedRelation", "columnAliases", "createColumnAliases", "relationPrimary", + "subQueryRelation", "unnest", "parenthesizedRelation", "columnItem", "expression", + "booleanExpression", "predicate", "valueExpression", "primaryExpression", + "stringLiteral", "comparisonOperator", "comparisonQuantifier", "booleanValue", + "interval", "intervalField", "normalForm", "type", "typeParameter", "baseType", + "whenClause", "filter", "over", "windowFrame", "frameBound", "pathElement", + "pathSpecification", "privilege", "objectType", "qualifiedName", "principal", + "identifier", "number", "nonReserved", + ]; + + private static readonly _LITERAL_NAMES: Array = [ + undefined, "'ADD'", "'ALL'", "'ANALYTIC'", "'ALTER'", "'AND'", "'ANY'", + "'ANTI'", "'ARRAY'", "'AS'", "'ASC'", "'AT'", "'AGGREGATE'", "'AUTHORIZATION'", + "'BERNOULLI'", "'BETWEEN'", "'BLOCK_SIZE'", "'PARTITIONED'", "'PREPARE_FN'", + "'EXTERNAL'", "'CLOSEFN'", "'SORT'", "'PURGE'", "'STORED'", "'LOCATION'", + "'TBLPROPERTIES'", "'BY'", "'CASCADE'", "'CASE'", "'CAST'", "'CACHED'", + "'CHANGE'", "'COLUMN'", "'COLUMNS'", "'COMMENT'", "'COMPRESSION'", "'COMPUTE'", + "'CREATE'", "'CROSS'", "'CURRENT'", "'CURRENT_DATE'", "'CURRENT_PATH'", + "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", "'CURRENT_USER'", "'DATA'", "'DATABASE'", + "'DATABASES'", "'DAY'", "'DAYS'", "'DELETE'", "'DEFAULT'", "'DELIMITED'", + "'DISABLE'", "'UPDATE'", "'DESC'", "'DESCRIBE'", "'DISTINCT'", "'DROP'", + "'ELSE'", "'ENCODING'", "'END'", "'ESCAPE'", "'ESCAPED'", "'EXCEPT'", + "'EXCLUDING'", "'EXISTS'", "'EXPLAIN'", "'EXTRACT'", "'EXTENDED'", "'FALSE'", + "'FIELDS'", "'FILEFORMAT'", "'FILES'", "'FILTER'", "'FIRST'", "'FINALIZE_FN'", + "'FOLLOWING'", "'FOR'", "'FORMAT'", "'FORMATTED'", "'FOREIGN'", "'FROM'", + "'FULL'", "'FUNCTION'", "'FUNCTIONS'", "'GRANT'", "'GROUP'", "'GROUPING'", + "'HASH'", "'HAVING'", "'HOUR'", "'HOURS'", "'IF'", "'IN'", "'INCLUDING'", + "'INCREMENTAL'", "'INNER'", "'INPATH'", "'INSERT'", "'INTERSECT'", "'INTERVAL'", + "'INTERMEDIATE'", "'INTO'", "'INIT_FN'", "'INVALIDATE'", "'IS'", "'JOIN'", + "'KEY'", "'KUDU'", "'LAST'", "'LATERAL'", "'LEFT'", "'LIKE'", "'LIMIT'", + "'LINES'", "'LOAD'", "'LOCALTIME'", "'LOCALTIMESTAMP'", "'METADATA'", + "'MAP'", "'MINUTE'", "'MINUTES'", "'MONTH'", "'MONTHS'", "'MERGE_FN'", + "'NFC'", "'NFD'", "'NFKC'", "'NFKD'", "'NORMALIZE'", "'NOT'", "'NULL'", + "'NULLS'", "'OFFSET'", "'ON'", "'OPTION'", "'OR'", "'ORDER'", "'ORDINALITY'", + "'OUTER'", "'OWNER'", "'OVER'", "'OVERWRITE'", "'PARTITION'", "'PARTITIONS'", + "'PARQUET'", "'POSITION'", "'PRECEDING'", "'PRIMARY'", "'REPLICATION'", + "'PRIVILEGES'", "'PROPERTIES'", "'RANGE'", "'RECOVER'", "'RENAME'", "'REPEATABLE'", + "'REPLACE'", "'RESTRICT'", "'RETURNS'", "'REVOKE'", "'REFRESH'", "'REGEXP'", + "'RLIKE'", "'RIGHT'", "'ROLE'", "'ROLES'", "'ROW'", "'ROWS'", "'SCHEMA'", + "'SCHEMAS'", "'SECOND'", "'SECONDS'", "'SELECT'", "'SERDEPROPERTIES'", + "'SET'", "'SEMI'", "'SERVER'", "'SHOW'", "'SHUTDOWN'", "'SOME'", "'STATS'", + "'STRUCT'", "'STRAIGHT_JOIN'", "'SUBSTRING'", "'SYSTEM'", "'SYMBOL'", + "'SERIALIZE_FN'", "'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TERMINATED '", + "'THEN'", "'TO'", "'TRUE'", "'TRY_CAST'", "'TRUNCATE'", "'UNCACHED'", + "'UESCAPE'", "'UNBOUNDED'", "'UNION'", "'UNNEST'", "'UNSET'", "'USE'", + "'USER'", "'USING'", "'UPDATE_FN'", "'UPSERT'", "'URI'", "'VALUE'", "'VALUES'", + "'VIEW'", "'VIEWS'", "'WHEN'", "'WHERE'", "'WITH'", "'YEAR'", "'YEARS'", + "'TEXTFILE'", "'ORC'", "'AVRO'", "'SEQUENCEFILE'", "'RCFILE'", "'REFERENCES'", + "'NOVALIDATE'", "'RELY'", "''UMDVS''", "''UMNULLS''", "''VGSIZE''", "''AXSIZE''", + "'='", undefined, "'<'", "'<='", "'>'", "'>='", "'+'", "'-'", "'*'", "'/'", + "'%'", "'||'", "'.'", "';'", "','", "':'", "'('", "')'", "'['", "']'", + "'{'", "'}'", "'|'", "'?'", "'->'", + ]; + private static readonly _SYMBOLIC_NAMES: Array = [ + undefined, "KW_ADD", "KW_ALL", "KW_ANALYTIC", "KW_ALTER", "KW_AND", "KW_ANY", + "KW_ANTI", "KW_ARRAY", "KW_AS", "KW_ASC", "KW_AT", "KW_AGGREGATE", "KW_AUTHORIZATION", + "KW_BERNOULLI", "KW_BETWEEN", "KW_BLOCK_SIZE", "KW_PARTITIONED", "KW_PREPARE_FN", + "KW_EXTERNAL", "KW_CLOSEFN", "KW_SORT", "KW_PURGE", "KW_STORED", "KW_LOCATION", + "KW_TBLPROPERTIES", "KW_BY", "KW_CASCADE", "KW_CASE", "KW_CAST", "KW_CACHED", + "KW_CHANGE", "KW_COLUMN", "KW_COLUMNS", "KW_COMMENT", "KW_COMPRESSION", + "KW_COMPUTE", "KW_CREATE", "KW_CROSS", "KW_CURRENT", "KW_CURRENT_DATE", + "KW_CURRENT_PATH", "KW_CURRENT_TIME", "KW_CURRENT_TIMESTAMP", "KW_CURRENT_USER", + "KW_DATA", "KW_DATABASE", "KW_DATABASES", "KW_DAY", "KW_DAYS", "KW_DELETE", + "KW_DEFAULT", "KW_DELIMITED", "KW_DISABLE", "KW_UPDATE", "KW_DESC", "KW_DESCRIBE", + "KW_DISTINCT", "KW_DROP", "KW_ELSE", "KW_ENCODING", "KW_END", "KW_ESCAPE", + "KW_ESCAPED", "KW_EXCEPT", "KW_EXCLUDING", "KW_EXISTS", "KW_EXPLAIN", + "KW_EXTRACT", "KW_EXTENDED", "KW_FALSE", "KW_FIELDS", "KW_FILEFORMAT", + "KW_FILES", "KW_FILTER", "KW_FIRST", "KW_FINALIZE_FN", "KW_FOLLOWING", + "KW_FOR", "KW_FORMAT", "KW_FORMATTED", "KW_FOREIGN", "KW_FROM", "KW_FULL", + "KW_FUNCTION", "KW_FUNCTIONS", "KW_GRANT", "KW_GROUP", "KW_GROUPING", + "KW_HASH", "KW_HAVING", "KW_HOUR", "KW_HOURS", "KW_IF", "KW_IN", "KW_INCLUDING", + "KW_INCREMENTAL", "KW_INNER", "KW_INPATH", "KW_INSERT", "KW_INTERSECT", + "KW_INTERVAL", "KW_INTERMEDIATE", "KW_INTO", "KW_INIT_FN", "KW_INVALIDATE", + "KW_IS", "KW_JOIN", "KW_KEY", "KW_KUDU", "KW_LAST", "KW_LATERAL", "KW_LEFT", + "KW_LIKE", "KW_LIMIT", "KW_LINES", "KW_LOAD", "KW_LOCALTIME", "KW_LOCALTIMESTAMP", + "KW_METADATA", "KW_MAP", "KW_MINUTE", "KW_MINUTES", "KW_MONTH", "KW_MONTHS", + "KW_MERGE_FN", "KW_NFC", "KW_NFD", "KW_NFKC", "KW_NFKD", "KW_NORMALIZE", + "KW_NOT", "KW_NULL", "KW_NULLS", "KW_OFFSET", "KW_ON", "KW_OPTION", "KW_OR", + "KW_ORDER", "KW_ORDINALITY", "KW_OUTER", "KW_OWNER", "KW_OVER", "KW_OVERWRITE", + "KW_PARTITION", "KW_PARTITIONS", "KW_PARQUET", "KW_POSITION", "KW_PRECEDING", + "KW_PRIMARY", "KW_REPLICATION", "KW_PRIVILEGES", "KW_PROPERTIES", "KW_RANGE", + "KW_RECOVER", "KW_RENAME", "KW_REPEATABLE", "KW_REPLACE", "KW_RESTRICT", + "KW_RETURNS", "KW_REVOKE", "KW_REFRESH", "KW_REGEXP", "KW_RLIKE", "KW_RIGHT", + "KW_ROLE", "KW_ROLES", "KW_ROW", "KW_ROWS", "KW_SCHEMA", "KW_SCHEMAS", + "KW_SECOND", "KW_SECONDS", "KW_SELECT", "KW_SERDEPROPERTIES", "KW_SET", + "KW_SEMI", "KW_SERVER", "KW_SHOW", "KW_SHUTDOWN", "KW_SOME", "KW_STATS", + "KW_STRUCT", "KW_STRAIGHT_JOIN", "KW_SUBSTRING", "KW_SYSTEM", "KW_SYMBOL", + "KW_SERIALIZE_FN", "KW_TABLE", "KW_TABLES", "KW_TABLESAMPLE", "KW_TERMINATED", + "KW_THEN", "KW_TO", "KW_TRUE", "KW_TRY_CAST", "KW_TRUNCATE", "KW_UNCACHED", + "KW_UESCAPE", "KW_UNBOUNDED", "KW_UNION", "KW_UNNEST", "KW_UNSET", "KW_USE", + "KW_USER", "KW_USING", "KW_UPDATE_FN", "KW_UPSERT", "KW_URI", "KW_VALUE", + "KW_VALUES", "KW_VIEW", "KW_VIEWS", "KW_WHEN", "KW_WHERE", "KW_WITH", + "KW_YEAR", "KW_YEARS", "KW_TEXTFILE", "KW_ORC", "KW_AVRO", "KW_SEQUENCEFILE", + "KW_RCFILE", "KW_REFERENCES", "KW_NOVALIDATE", "KW_RELY", "STATS_NUMDVS", + "STATS_NUMNULLS", "STATS_AVGSIZE", "STATS_MAXSIZE", "EQ", "NEQ", "LT", + "LTE", "GT", "GTE", "PLUS", "MINUS", "ASTERISK", "SLASH", "PERCENT", "CONCAT", + "DOT", "SEMICOLON", "COMMA", "COLON", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", + "LCURLY", "RCURLY", "BITWISEOR", "QUESTION", "RIGHT_ARROW", "STRING", + "UNICODE_STRING", "BINARY_LITERAL", "INTEGER_VALUE", "DECIMAL_VALUE", + "DOUBLE_VALUE", "IDENTIFIER", "DIGIT_IDENTIFIER", "QUOTED_IDENTIFIER", + "BACKQUOTED_IDENTIFIER", "TIME_WITH_TIME_ZONE", "TIMESTAMP_WITH_TIME_ZONE", + "DOUBLE_PRECISION", "SIMPLE_COMMENT", "BRACKETED_COMMENT", "WS", + ]; + public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(ImpalaSqlParser._LITERAL_NAMES, ImpalaSqlParser._SYMBOLIC_NAMES, []); + + // @Override + // @NotNull + public get vocabulary(): Vocabulary { + return ImpalaSqlParser.VOCABULARY; + } + // tslint:enable:no-trailing-whitespace + + // @Override + public get grammarFileName(): string { return "ImpalaSqlParser.g4"; } + + // @Override + public get ruleNames(): string[] { return ImpalaSqlParser.ruleNames; } + + // @Override + public get serializedATN(): string { return ImpalaSqlParser._serializedATN; } + + protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException { + return new FailedPredicateException(this, predicate, message); + } + + constructor(input: TokenStream) { + super(input); + this._interp = new ParserATNSimulator(ImpalaSqlParser._ATN, this); + } + // @RuleVersion(0) + public program(): ProgramContext { + let _localctx: ProgramContext = new ProgramContext(this._ctx, this.state); + this.enterRule(_localctx, 0, ImpalaSqlParser.RULE_program); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 366; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.KW_ALTER || _la === ImpalaSqlParser.KW_COMMENT || ((((_la - 36)) & ~0x1F) === 0 && ((1 << (_la - 36)) & ((1 << (ImpalaSqlParser.KW_COMPUTE - 36)) | (1 << (ImpalaSqlParser.KW_CREATE - 36)) | (1 << (ImpalaSqlParser.KW_DELETE - 36)) | (1 << (ImpalaSqlParser.KW_UPDATE - 36)) | (1 << (ImpalaSqlParser.KW_DESCRIBE - 36)) | (1 << (ImpalaSqlParser.KW_DROP - 36)) | (1 << (ImpalaSqlParser.KW_EXPLAIN - 36)))) !== 0) || ((((_la - 86)) & ~0x1F) === 0 && ((1 << (_la - 86)) & ((1 << (ImpalaSqlParser.KW_GRANT - 86)) | (1 << (ImpalaSqlParser.KW_INSERT - 86)) | (1 << (ImpalaSqlParser.KW_INVALIDATE - 86)) | (1 << (ImpalaSqlParser.KW_LOAD - 86)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (ImpalaSqlParser.KW_REVOKE - 160)) | (1 << (ImpalaSqlParser.KW_REFRESH - 160)) | (1 << (ImpalaSqlParser.KW_SELECT - 160)) | (1 << (ImpalaSqlParser.KW_SET - 160)) | (1 << (ImpalaSqlParser.KW_SHOW - 160)) | (1 << (ImpalaSqlParser.KW_TABLE - 160)))) !== 0) || ((((_la - 196)) & ~0x1F) === 0 && ((1 << (_la - 196)) & ((1 << (ImpalaSqlParser.KW_TRUNCATE - 196)) | (1 << (ImpalaSqlParser.KW_USE - 196)) | (1 << (ImpalaSqlParser.KW_UPSERT - 196)) | (1 << (ImpalaSqlParser.KW_VALUES - 196)) | (1 << (ImpalaSqlParser.KW_WITH - 196)))) !== 0) || _la === ImpalaSqlParser.COLON || _la === ImpalaSqlParser.LPAREN) { + { + { + this.state = 360; + this.statement(); + this.state = 362; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.SEMICOLON) { + { + this.state = 361; + this.match(ImpalaSqlParser.SEMICOLON); + } + } + + } + } + this.state = 368; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 369; + this.match(ImpalaSqlParser.EOF); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public statement(): StatementContext { + let _localctx: StatementContext = new StatementContext(this._ctx, this.state); + this.enterRule(_localctx, 2, ImpalaSqlParser.RULE_statement); + try { + this.state = 393; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 2, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 371; + this.queryStatement(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 372; + this.useStatement(); + } + break; + + case 3: + this.enterOuterAlt(_localctx, 3); + { + this.state = 373; + this.createStatement(); + } + break; + + case 4: + this.enterOuterAlt(_localctx, 4); + { + this.state = 374; + this.alterStatement(); + } + break; + + case 5: + this.enterOuterAlt(_localctx, 5); + { + this.state = 375; + this.truncateTableStatement(); + } + break; + + case 6: + this.enterOuterAlt(_localctx, 6); + { + this.state = 376; + this.describeStatement(); + } + break; + + case 7: + this.enterOuterAlt(_localctx, 7); + { + this.state = 377; + this.computeStatement(); + } + break; + + case 8: + this.enterOuterAlt(_localctx, 8); + { + this.state = 378; + this.dropStatement(); + } + break; + + case 9: + this.enterOuterAlt(_localctx, 9); + { + this.state = 379; + this.grantStatement(); + } + break; + + case 10: + this.enterOuterAlt(_localctx, 10); + { + this.state = 380; + this.revokeStatement(); + } + break; + + case 11: + this.enterOuterAlt(_localctx, 11); + { + this.state = 381; + this.insertStatement(); + } + break; + + case 12: + this.enterOuterAlt(_localctx, 12); + { + this.state = 382; + this.deleteStatement(); + } + break; + + case 13: + this.enterOuterAlt(_localctx, 13); + { + this.state = 383; + this.updateStatement(); + } + break; + + case 14: + this.enterOuterAlt(_localctx, 14); + { + this.state = 384; + this.upsertStatement(); + } + break; + + case 15: + this.enterOuterAlt(_localctx, 15); + { + this.state = 385; + this.showStatement(); + } + break; + + case 16: + this.enterOuterAlt(_localctx, 16); + { + this.state = 386; + this.addCommentStatement(); + } + break; + + case 17: + this.enterOuterAlt(_localctx, 17); + { + this.state = 387; + this.explainStatement(); + } + break; + + case 18: + this.enterOuterAlt(_localctx, 18); + { + this.state = 388; + this.setStatement(); + } + break; + + case 19: + this.enterOuterAlt(_localctx, 19); + { + this.state = 389; + this.shutdownStatement(); + } + break; + + case 20: + this.enterOuterAlt(_localctx, 20); + { + this.state = 390; + this.invalidateMetaStatement(); + } + break; + + case 21: + this.enterOuterAlt(_localctx, 21); + { + this.state = 391; + this.loadDataStatement(); + } + break; + + case 22: + this.enterOuterAlt(_localctx, 22); + { + this.state = 392; + this.refreshStatement(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public useStatement(): UseStatementContext { + let _localctx: UseStatementContext = new UseStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 4, ImpalaSqlParser.RULE_useStatement); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 395; + this.match(ImpalaSqlParser.KW_USE); + this.state = 396; + this.databaseNamePath(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public createStatement(): CreateStatementContext { + let _localctx: CreateStatementContext = new CreateStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 6, ImpalaSqlParser.RULE_createStatement); + try { + this.state = 406; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 3, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 398; + this.createSchema(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 399; + this.createRole(); + } + break; + + case 3: + this.enterOuterAlt(_localctx, 3); + { + this.state = 400; + this.createAggregateFunction(); + } + break; + + case 4: + this.enterOuterAlt(_localctx, 4); + { + this.state = 401; + this.createFunction(); + } + break; + + case 5: + this.enterOuterAlt(_localctx, 5); + { + this.state = 402; + this.createView(); + } + break; + + case 6: + this.enterOuterAlt(_localctx, 6); + { + this.state = 403; + this.createKuduTableAsSelect(); + } + break; + + case 7: + this.enterOuterAlt(_localctx, 7); + { + this.state = 404; + this.createTableLike(); + } + break; + + case 8: + this.enterOuterAlt(_localctx, 8); + { + this.state = 405; + this.createTableSelect(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public createTableSelect(): CreateTableSelectContext { + let _localctx: CreateTableSelectContext = new CreateTableSelectContext(this._ctx, this.state); + this.enterRule(_localctx, 8, ImpalaSqlParser.RULE_createTableSelect); + let _la: number; + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 408; + this.match(ImpalaSqlParser.KW_CREATE); + this.state = 410; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_EXTERNAL) { + { + this.state = 409; + this.match(ImpalaSqlParser.KW_EXTERNAL); + } + } + + this.state = 412; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 414; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 5, this._ctx) ) { + case 1: + { + this.state = 413; + this.ifNotExists(); + } + break; + } + this.state = 416; + this.tableNameCreate(); + this.state = 432; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 8, this._ctx) ) { + case 1: + { + this.state = 417; + this.match(ImpalaSqlParser.LPAREN); + this.state = 418; + this.columnDefinition(); + this.state = 423; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + { + { + this.state = 419; + this.match(ImpalaSqlParser.COMMA); + this.state = 420; + this.columnDefinition(); + } + } + } + this.state = 425; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx); + } + this.state = 428; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.COMMA) { + { + this.state = 426; + this.match(ImpalaSqlParser.COMMA); + this.state = 427; + this.constraintSpecification(); + } + } + + this.state = 430; + this.match(ImpalaSqlParser.RPAREN); + } + break; + } + this.state = 440; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PARTITIONED) { + { + this.state = 434; + this.match(ImpalaSqlParser.KW_PARTITIONED); + this.state = 435; + this.match(ImpalaSqlParser.KW_BY); + this.state = 438; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 9, this._ctx) ) { + case 1: + { + this.state = 436; + this.partitionedBy(); + } + break; + + case 2: + { + this.state = 437; + this.createColumnAliases(); + } + break; + } + } + } + + this.state = 442; + this.createCommonItem(); + this.state = 445; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_AS) { + { + this.state = 443; + this.match(ImpalaSqlParser.KW_AS); + this.state = 444; + this.queryStatement(); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public createTableLike(): CreateTableLikeContext { + let _localctx: CreateTableLikeContext = new CreateTableLikeContext(this._ctx, this.state); + this.enterRule(_localctx, 10, ImpalaSqlParser.RULE_createTableLike); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 447; + this.match(ImpalaSqlParser.KW_CREATE); + this.state = 449; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_EXTERNAL) { + { + this.state = 448; + this.match(ImpalaSqlParser.KW_EXTERNAL); + } + } + + this.state = 451; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 453; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 13, this._ctx) ) { + case 1: + { + this.state = 452; + this.ifNotExists(); + } + break; + } + this.state = 455; + this.tableNameCreate(); + this.state = 456; + this.match(ImpalaSqlParser.KW_LIKE); + this.state = 460; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 14, this._ctx) ) { + case 1: + { + this.state = 457; + this.tableNamePath(); + } + break; + + case 2: + { + this.state = 458; + this.match(ImpalaSqlParser.KW_PARQUET); + this.state = 459; + _localctx._parquet = this.stringLiteral(); + } + break; + } + this.state = 465; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PARTITIONED) { + { + this.state = 462; + this.match(ImpalaSqlParser.KW_PARTITIONED); + this.state = 463; + this.match(ImpalaSqlParser.KW_BY); + this.state = 464; + this.partitionedBy(); + } + } + + this.state = 467; + this.createCommonItem(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public createKuduTableAsSelect(): CreateKuduTableAsSelectContext { + let _localctx: CreateKuduTableAsSelectContext = new CreateKuduTableAsSelectContext(this._ctx, this.state); + this.enterRule(_localctx, 12, ImpalaSqlParser.RULE_createKuduTableAsSelect); + let _la: number; + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 469; + this.match(ImpalaSqlParser.KW_CREATE); + this.state = 471; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_EXTERNAL) { + { + this.state = 470; + this.match(ImpalaSqlParser.KW_EXTERNAL); + } + } + + this.state = 473; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 475; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 17, this._ctx) ) { + case 1: + { + this.state = 474; + this.ifNotExists(); + } + break; + } + this.state = 477; + this.tableNameCreate(); + this.state = 495; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.LPAREN) { + { + this.state = 478; + this.match(ImpalaSqlParser.LPAREN); + this.state = 479; + this.kuduTableElement(); + this.state = 484; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 18, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + { + { + this.state = 480; + this.match(ImpalaSqlParser.COMMA); + this.state = 481; + this.kuduTableElement(); + } + } + } + this.state = 486; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 18, this._ctx); + } + this.state = 491; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.COMMA) { + { + this.state = 487; + this.match(ImpalaSqlParser.COMMA); + this.state = 488; + this.match(ImpalaSqlParser.KW_PRIMARY); + this.state = 489; + this.match(ImpalaSqlParser.KW_KEY); + this.state = 490; + this.columnAliases(); + } + } + + this.state = 493; + this.match(ImpalaSqlParser.RPAREN); + } + } + + this.state = 502; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PRIMARY) { + { + this.state = 497; + this.match(ImpalaSqlParser.KW_PRIMARY); + this.state = 498; + this.match(ImpalaSqlParser.KW_KEY); + this.state = 500; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.LPAREN) { + { + this.state = 499; + this.columnAliases(); + } + } + + } + } + + this.state = 507; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PARTITION) { + { + this.state = 504; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 505; + this.match(ImpalaSqlParser.KW_BY); + this.state = 506; + this.kuduPartitionClause(); + } + } + + this.state = 511; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_COMMENT) { + { + this.state = 509; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 510; + this.stringLiteral(); + } + } + + this.state = 513; + this.match(ImpalaSqlParser.KW_STORED); + this.state = 514; + this.match(ImpalaSqlParser.KW_AS); + this.state = 515; + this.match(ImpalaSqlParser.KW_KUDU); + this.state = 518; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_TBLPROPERTIES) { + { + this.state = 516; + this.match(ImpalaSqlParser.KW_TBLPROPERTIES); + this.state = 517; + _localctx._tblProp = this.properties(); + } + } + + this.state = 522; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_AS) { + { + this.state = 520; + this.match(ImpalaSqlParser.KW_AS); + this.state = 521; + this.queryStatement(); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public createView(): CreateViewContext { + let _localctx: CreateViewContext = new CreateViewContext(this._ctx, this.state); + this.enterRule(_localctx, 14, ImpalaSqlParser.RULE_createView); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 524; + this.match(ImpalaSqlParser.KW_CREATE); + this.state = 525; + this.match(ImpalaSqlParser.KW_VIEW); + this.state = 527; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 27, this._ctx) ) { + case 1: + { + this.state = 526; + this.ifNotExists(); + } + break; + } + this.state = 529; + this.viewNameCreate(); + this.state = 531; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.LPAREN) { + { + this.state = 530; + this.viewColumns(); + } + } + + this.state = 535; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_COMMENT) { + { + this.state = 533; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 534; + this.stringLiteral(); + } + } + + this.state = 539; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_TBLPROPERTIES) { + { + this.state = 537; + this.match(ImpalaSqlParser.KW_TBLPROPERTIES); + this.state = 538; + _localctx._tblProp = this.properties(); + } + } + + this.state = 541; + this.match(ImpalaSqlParser.KW_AS); + this.state = 542; + this.queryStatement(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public createSchema(): CreateSchemaContext { + let _localctx: CreateSchemaContext = new CreateSchemaContext(this._ctx, this.state); + this.enterRule(_localctx, 16, ImpalaSqlParser.RULE_createSchema); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 544; + this.match(ImpalaSqlParser.KW_CREATE); + this.state = 545; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_DATABASE || _la === ImpalaSqlParser.KW_SCHEMA)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 547; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 31, this._ctx) ) { + case 1: + { + this.state = 546; + this.ifNotExists(); + } + break; + } + this.state = 549; + this.databaseNameCreate(); + this.state = 552; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 32, this._ctx) ) { + case 1: + { + this.state = 550; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 551; + _localctx._comment = this.stringLiteral(); + } + break; + } + this.state = 556; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_LOCATION) { + { + this.state = 554; + this.match(ImpalaSqlParser.KW_LOCATION); + this.state = 555; + _localctx._location = this.stringLiteral(); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public createRole(): CreateRoleContext { + let _localctx: CreateRoleContext = new CreateRoleContext(this._ctx, this.state); + this.enterRule(_localctx, 18, ImpalaSqlParser.RULE_createRole); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 558; + this.match(ImpalaSqlParser.KW_CREATE); + this.state = 559; + this.match(ImpalaSqlParser.KW_ROLE); + this.state = 560; + _localctx._name = this.identifier(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public createAggregateFunction(): CreateAggregateFunctionContext { + let _localctx: CreateAggregateFunctionContext = new CreateAggregateFunctionContext(this._ctx, this.state); + this.enterRule(_localctx, 20, ImpalaSqlParser.RULE_createAggregateFunction); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 562; + this.match(ImpalaSqlParser.KW_CREATE); + this.state = 564; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_AGGREGATE) { + { + this.state = 563; + this.match(ImpalaSqlParser.KW_AGGREGATE); + } + } + + this.state = 566; + this.match(ImpalaSqlParser.KW_FUNCTION); + this.state = 568; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 35, this._ctx) ) { + case 1: + { + this.state = 567; + this.ifNotExists(); + } + break; + } + this.state = 570; + this.functionNameCreate(); + this.state = 583; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.LPAREN) { + { + this.state = 571; + this.match(ImpalaSqlParser.LPAREN); + this.state = 580; + this._errHandler.sync(this); + _la = this._input.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ImpalaSqlParser.KW_ADD) | (1 << ImpalaSqlParser.KW_ALL) | (1 << ImpalaSqlParser.KW_ANY) | (1 << ImpalaSqlParser.KW_ARRAY) | (1 << ImpalaSqlParser.KW_ASC) | (1 << ImpalaSqlParser.KW_AT) | (1 << ImpalaSqlParser.KW_BERNOULLI) | (1 << ImpalaSqlParser.KW_CASCADE))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (ImpalaSqlParser.KW_COLUMN - 32)) | (1 << (ImpalaSqlParser.KW_COLUMNS - 32)) | (1 << (ImpalaSqlParser.KW_COMMENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT - 32)) | (1 << (ImpalaSqlParser.KW_DATA - 32)) | (1 << (ImpalaSqlParser.KW_DATABASE - 32)) | (1 << (ImpalaSqlParser.KW_DATABASES - 32)) | (1 << (ImpalaSqlParser.KW_DAY - 32)) | (1 << (ImpalaSqlParser.KW_DAYS - 32)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 32)) | (1 << (ImpalaSqlParser.KW_DESC - 32)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (ImpalaSqlParser.KW_EXCLUDING - 65)) | (1 << (ImpalaSqlParser.KW_EXPLAIN - 65)) | (1 << (ImpalaSqlParser.KW_FILTER - 65)) | (1 << (ImpalaSqlParser.KW_FIRST - 65)) | (1 << (ImpalaSqlParser.KW_FOLLOWING - 65)) | (1 << (ImpalaSqlParser.KW_FORMAT - 65)) | (1 << (ImpalaSqlParser.KW_FUNCTIONS - 65)) | (1 << (ImpalaSqlParser.KW_GRANT - 65)) | (1 << (ImpalaSqlParser.KW_HOUR - 65)) | (1 << (ImpalaSqlParser.KW_IF - 65)) | (1 << (ImpalaSqlParser.KW_INCLUDING - 65)))) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (ImpalaSqlParser.KW_INTERVAL - 101)) | (1 << (ImpalaSqlParser.KW_LAST - 101)) | (1 << (ImpalaSqlParser.KW_LATERAL - 101)) | (1 << (ImpalaSqlParser.KW_LIMIT - 101)) | (1 << (ImpalaSqlParser.KW_MAP - 101)) | (1 << (ImpalaSqlParser.KW_MINUTE - 101)) | (1 << (ImpalaSqlParser.KW_MONTH - 101)) | (1 << (ImpalaSqlParser.KW_NFC - 101)) | (1 << (ImpalaSqlParser.KW_NFD - 101)) | (1 << (ImpalaSqlParser.KW_NFKC - 101)) | (1 << (ImpalaSqlParser.KW_NFKD - 101)))) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & ((1 << (ImpalaSqlParser.KW_NULLS - 133)) | (1 << (ImpalaSqlParser.KW_OFFSET - 133)) | (1 << (ImpalaSqlParser.KW_OPTION - 133)) | (1 << (ImpalaSqlParser.KW_ORDINALITY - 133)) | (1 << (ImpalaSqlParser.KW_OVER - 133)) | (1 << (ImpalaSqlParser.KW_PARTITION - 133)) | (1 << (ImpalaSqlParser.KW_PARTITIONS - 133)) | (1 << (ImpalaSqlParser.KW_PARQUET - 133)) | (1 << (ImpalaSqlParser.KW_POSITION - 133)) | (1 << (ImpalaSqlParser.KW_PRECEDING - 133)) | (1 << (ImpalaSqlParser.KW_PRIVILEGES - 133)) | (1 << (ImpalaSqlParser.KW_PROPERTIES - 133)) | (1 << (ImpalaSqlParser.KW_RANGE - 133)) | (1 << (ImpalaSqlParser.KW_RENAME - 133)) | (1 << (ImpalaSqlParser.KW_REPEATABLE - 133)) | (1 << (ImpalaSqlParser.KW_REPLACE - 133)) | (1 << (ImpalaSqlParser.KW_RESTRICT - 133)) | (1 << (ImpalaSqlParser.KW_REVOKE - 133)))) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & ((1 << (ImpalaSqlParser.KW_ROLE - 165)) | (1 << (ImpalaSqlParser.KW_ROLES - 165)) | (1 << (ImpalaSqlParser.KW_ROW - 165)) | (1 << (ImpalaSqlParser.KW_ROWS - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMA - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMAS - 165)) | (1 << (ImpalaSqlParser.KW_SECOND - 165)) | (1 << (ImpalaSqlParser.KW_SECONDS - 165)) | (1 << (ImpalaSqlParser.KW_SET - 165)) | (1 << (ImpalaSqlParser.KW_SHOW - 165)) | (1 << (ImpalaSqlParser.KW_SOME - 165)) | (1 << (ImpalaSqlParser.KW_STATS - 165)) | (1 << (ImpalaSqlParser.KW_STRUCT - 165)) | (1 << (ImpalaSqlParser.KW_SUBSTRING - 165)) | (1 << (ImpalaSqlParser.KW_SYSTEM - 165)) | (1 << (ImpalaSqlParser.KW_TABLES - 165)) | (1 << (ImpalaSqlParser.KW_TABLESAMPLE - 165)) | (1 << (ImpalaSqlParser.KW_TO - 165)) | (1 << (ImpalaSqlParser.KW_TRY_CAST - 165)) | (1 << (ImpalaSqlParser.KW_TRUNCATE - 165)))) !== 0) || ((((_la - 199)) & ~0x1F) === 0 && ((1 << (_la - 199)) & ((1 << (ImpalaSqlParser.KW_UNBOUNDED - 199)) | (1 << (ImpalaSqlParser.KW_USE - 199)) | (1 << (ImpalaSqlParser.KW_USER - 199)) | (1 << (ImpalaSqlParser.KW_VIEW - 199)) | (1 << (ImpalaSqlParser.KW_VIEWS - 199)) | (1 << (ImpalaSqlParser.KW_YEAR - 199)) | (1 << (ImpalaSqlParser.KW_TEXTFILE - 199)) | (1 << (ImpalaSqlParser.KW_ORC - 199)) | (1 << (ImpalaSqlParser.KW_AVRO - 199)) | (1 << (ImpalaSqlParser.KW_SEQUENCEFILE - 199)) | (1 << (ImpalaSqlParser.KW_RCFILE - 199)))) !== 0) || ((((_la - 255)) & ~0x1F) === 0 && ((1 << (_la - 255)) & ((1 << (ImpalaSqlParser.STRING - 255)) | (1 << (ImpalaSqlParser.IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.DIGIT_IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.BACKQUOTED_IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.TIME_WITH_TIME_ZONE - 255)) | (1 << (ImpalaSqlParser.TIMESTAMP_WITH_TIME_ZONE - 255)) | (1 << (ImpalaSqlParser.DOUBLE_PRECISION - 255)))) !== 0)) { + { + this.state = 572; + this.type(0); + this.state = 577; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 573; + this.match(ImpalaSqlParser.COMMA); + this.state = 574; + this.type(0); + } + } + this.state = 579; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + this.state = 582; + this.match(ImpalaSqlParser.RPAREN); + } + } + + this.state = 585; + this.match(ImpalaSqlParser.KW_RETURNS); + this.state = 586; + this.type(0); + this.state = 589; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_INTERMEDIATE) { + { + this.state = 587; + this.match(ImpalaSqlParser.KW_INTERMEDIATE); + this.state = 588; + this.type(0); + } + } + + this.state = 591; + this.match(ImpalaSqlParser.KW_LOCATION); + this.state = 592; + this.match(ImpalaSqlParser.STRING); + this.state = 596; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_INIT_FN) { + { + this.state = 593; + this.match(ImpalaSqlParser.KW_INIT_FN); + this.state = 594; + this.match(ImpalaSqlParser.EQ); + this.state = 595; + this.match(ImpalaSqlParser.STRING); + } + } + + this.state = 598; + this.match(ImpalaSqlParser.KW_UPDATE_FN); + this.state = 599; + this.match(ImpalaSqlParser.EQ); + this.state = 600; + this.match(ImpalaSqlParser.STRING); + this.state = 601; + this.match(ImpalaSqlParser.KW_MERGE_FN); + this.state = 602; + this.match(ImpalaSqlParser.EQ); + this.state = 603; + this.match(ImpalaSqlParser.STRING); + this.state = 607; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PREPARE_FN) { + { + this.state = 604; + this.match(ImpalaSqlParser.KW_PREPARE_FN); + this.state = 605; + this.match(ImpalaSqlParser.EQ); + this.state = 606; + this.match(ImpalaSqlParser.STRING); + } + } + + this.state = 612; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_CLOSEFN) { + { + this.state = 609; + this.match(ImpalaSqlParser.KW_CLOSEFN); + this.state = 610; + this.match(ImpalaSqlParser.EQ); + this.state = 611; + this.match(ImpalaSqlParser.STRING); + } + } + + this.state = 617; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_SERIALIZE_FN) { + { + this.state = 614; + this.match(ImpalaSqlParser.KW_SERIALIZE_FN); + this.state = 615; + this.match(ImpalaSqlParser.EQ); + this.state = 616; + this.match(ImpalaSqlParser.STRING); + } + } + + this.state = 622; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_FINALIZE_FN) { + { + this.state = 619; + this.match(ImpalaSqlParser.KW_FINALIZE_FN); + this.state = 620; + this.match(ImpalaSqlParser.EQ); + this.state = 621; + this.match(ImpalaSqlParser.STRING); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public createFunction(): CreateFunctionContext { + let _localctx: CreateFunctionContext = new CreateFunctionContext(this._ctx, this.state); + this.enterRule(_localctx, 22, ImpalaSqlParser.RULE_createFunction); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 624; + this.match(ImpalaSqlParser.KW_CREATE); + this.state = 625; + this.match(ImpalaSqlParser.KW_FUNCTION); + this.state = 627; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 45, this._ctx) ) { + case 1: + { + this.state = 626; + this.ifNotExists(); + } + break; + } + this.state = 629; + this.functionNameCreate(); + this.state = 642; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.LPAREN) { + { + this.state = 630; + this.match(ImpalaSqlParser.LPAREN); + this.state = 639; + this._errHandler.sync(this); + _la = this._input.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ImpalaSqlParser.KW_ADD) | (1 << ImpalaSqlParser.KW_ALL) | (1 << ImpalaSqlParser.KW_ANY) | (1 << ImpalaSqlParser.KW_ARRAY) | (1 << ImpalaSqlParser.KW_ASC) | (1 << ImpalaSqlParser.KW_AT) | (1 << ImpalaSqlParser.KW_BERNOULLI) | (1 << ImpalaSqlParser.KW_CASCADE))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (ImpalaSqlParser.KW_COLUMN - 32)) | (1 << (ImpalaSqlParser.KW_COLUMNS - 32)) | (1 << (ImpalaSqlParser.KW_COMMENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT - 32)) | (1 << (ImpalaSqlParser.KW_DATA - 32)) | (1 << (ImpalaSqlParser.KW_DATABASE - 32)) | (1 << (ImpalaSqlParser.KW_DATABASES - 32)) | (1 << (ImpalaSqlParser.KW_DAY - 32)) | (1 << (ImpalaSqlParser.KW_DAYS - 32)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 32)) | (1 << (ImpalaSqlParser.KW_DESC - 32)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (ImpalaSqlParser.KW_EXCLUDING - 65)) | (1 << (ImpalaSqlParser.KW_EXPLAIN - 65)) | (1 << (ImpalaSqlParser.KW_FILTER - 65)) | (1 << (ImpalaSqlParser.KW_FIRST - 65)) | (1 << (ImpalaSqlParser.KW_FOLLOWING - 65)) | (1 << (ImpalaSqlParser.KW_FORMAT - 65)) | (1 << (ImpalaSqlParser.KW_FUNCTIONS - 65)) | (1 << (ImpalaSqlParser.KW_GRANT - 65)) | (1 << (ImpalaSqlParser.KW_HOUR - 65)) | (1 << (ImpalaSqlParser.KW_IF - 65)) | (1 << (ImpalaSqlParser.KW_INCLUDING - 65)))) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (ImpalaSqlParser.KW_INTERVAL - 101)) | (1 << (ImpalaSqlParser.KW_LAST - 101)) | (1 << (ImpalaSqlParser.KW_LATERAL - 101)) | (1 << (ImpalaSqlParser.KW_LIMIT - 101)) | (1 << (ImpalaSqlParser.KW_MAP - 101)) | (1 << (ImpalaSqlParser.KW_MINUTE - 101)) | (1 << (ImpalaSqlParser.KW_MONTH - 101)) | (1 << (ImpalaSqlParser.KW_NFC - 101)) | (1 << (ImpalaSqlParser.KW_NFD - 101)) | (1 << (ImpalaSqlParser.KW_NFKC - 101)) | (1 << (ImpalaSqlParser.KW_NFKD - 101)))) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & ((1 << (ImpalaSqlParser.KW_NULLS - 133)) | (1 << (ImpalaSqlParser.KW_OFFSET - 133)) | (1 << (ImpalaSqlParser.KW_OPTION - 133)) | (1 << (ImpalaSqlParser.KW_ORDINALITY - 133)) | (1 << (ImpalaSqlParser.KW_OVER - 133)) | (1 << (ImpalaSqlParser.KW_PARTITION - 133)) | (1 << (ImpalaSqlParser.KW_PARTITIONS - 133)) | (1 << (ImpalaSqlParser.KW_PARQUET - 133)) | (1 << (ImpalaSqlParser.KW_POSITION - 133)) | (1 << (ImpalaSqlParser.KW_PRECEDING - 133)) | (1 << (ImpalaSqlParser.KW_PRIVILEGES - 133)) | (1 << (ImpalaSqlParser.KW_PROPERTIES - 133)) | (1 << (ImpalaSqlParser.KW_RANGE - 133)) | (1 << (ImpalaSqlParser.KW_RENAME - 133)) | (1 << (ImpalaSqlParser.KW_REPEATABLE - 133)) | (1 << (ImpalaSqlParser.KW_REPLACE - 133)) | (1 << (ImpalaSqlParser.KW_RESTRICT - 133)) | (1 << (ImpalaSqlParser.KW_REVOKE - 133)))) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & ((1 << (ImpalaSqlParser.KW_ROLE - 165)) | (1 << (ImpalaSqlParser.KW_ROLES - 165)) | (1 << (ImpalaSqlParser.KW_ROW - 165)) | (1 << (ImpalaSqlParser.KW_ROWS - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMA - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMAS - 165)) | (1 << (ImpalaSqlParser.KW_SECOND - 165)) | (1 << (ImpalaSqlParser.KW_SECONDS - 165)) | (1 << (ImpalaSqlParser.KW_SET - 165)) | (1 << (ImpalaSqlParser.KW_SHOW - 165)) | (1 << (ImpalaSqlParser.KW_SOME - 165)) | (1 << (ImpalaSqlParser.KW_STATS - 165)) | (1 << (ImpalaSqlParser.KW_STRUCT - 165)) | (1 << (ImpalaSqlParser.KW_SUBSTRING - 165)) | (1 << (ImpalaSqlParser.KW_SYSTEM - 165)) | (1 << (ImpalaSqlParser.KW_TABLES - 165)) | (1 << (ImpalaSqlParser.KW_TABLESAMPLE - 165)) | (1 << (ImpalaSqlParser.KW_TO - 165)) | (1 << (ImpalaSqlParser.KW_TRY_CAST - 165)) | (1 << (ImpalaSqlParser.KW_TRUNCATE - 165)))) !== 0) || ((((_la - 199)) & ~0x1F) === 0 && ((1 << (_la - 199)) & ((1 << (ImpalaSqlParser.KW_UNBOUNDED - 199)) | (1 << (ImpalaSqlParser.KW_USE - 199)) | (1 << (ImpalaSqlParser.KW_USER - 199)) | (1 << (ImpalaSqlParser.KW_VIEW - 199)) | (1 << (ImpalaSqlParser.KW_VIEWS - 199)) | (1 << (ImpalaSqlParser.KW_YEAR - 199)) | (1 << (ImpalaSqlParser.KW_TEXTFILE - 199)) | (1 << (ImpalaSqlParser.KW_ORC - 199)) | (1 << (ImpalaSqlParser.KW_AVRO - 199)) | (1 << (ImpalaSqlParser.KW_SEQUENCEFILE - 199)) | (1 << (ImpalaSqlParser.KW_RCFILE - 199)))) !== 0) || ((((_la - 255)) & ~0x1F) === 0 && ((1 << (_la - 255)) & ((1 << (ImpalaSqlParser.STRING - 255)) | (1 << (ImpalaSqlParser.IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.DIGIT_IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.BACKQUOTED_IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.TIME_WITH_TIME_ZONE - 255)) | (1 << (ImpalaSqlParser.TIMESTAMP_WITH_TIME_ZONE - 255)) | (1 << (ImpalaSqlParser.DOUBLE_PRECISION - 255)))) !== 0)) { + { + this.state = 631; + this.type(0); + this.state = 636; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 632; + this.match(ImpalaSqlParser.COMMA); + this.state = 633; + this.type(0); + } + } + this.state = 638; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + this.state = 641; + this.match(ImpalaSqlParser.RPAREN); + } + } + + this.state = 646; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_RETURNS) { + { + this.state = 644; + this.match(ImpalaSqlParser.KW_RETURNS); + this.state = 645; + this.type(0); + } + } + + this.state = 648; + this.match(ImpalaSqlParser.KW_LOCATION); + this.state = 649; + this.match(ImpalaSqlParser.STRING); + this.state = 650; + this.match(ImpalaSqlParser.KW_SYMBOL); + this.state = 651; + this.match(ImpalaSqlParser.EQ); + this.state = 652; + _localctx._symbol = this.stringLiteral(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public alterStatement(): AlterStatementContext { + let _localctx: AlterStatementContext = new AlterStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 24, ImpalaSqlParser.RULE_alterStatement); + try { + this.state = 672; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 50, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 654; + this.alterDatabase(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 655; + this.alterUnSetOrSetViewTblproperties(); + } + break; + + case 3: + this.enterOuterAlt(_localctx, 3); + { + this.state = 656; + this.renameTable(); + } + break; + + case 4: + this.enterOuterAlt(_localctx, 4); + { + this.state = 657; + this.alterViewOwner(); + } + break; + + case 5: + this.enterOuterAlt(_localctx, 5); + { + this.state = 658; + this.alterView(); + } + break; + + case 6: + this.enterOuterAlt(_localctx, 6); + { + this.state = 659; + this.renameView(); + } + break; + + case 7: + this.enterOuterAlt(_localctx, 7); + { + this.state = 660; + this.dropPartitionByRangeOrValue(); + } + break; + + case 8: + this.enterOuterAlt(_localctx, 8); + { + this.state = 661; + this.alterFormat(); + } + break; + + case 9: + this.enterOuterAlt(_localctx, 9); + { + this.state = 662; + this.recoverPartitions(); + } + break; + + case 10: + this.enterOuterAlt(_localctx, 10); + { + this.state = 663; + this.addPartitionByRangeOrValue(); + } + break; + + case 11: + this.enterOuterAlt(_localctx, 11); + { + this.state = 664; + this.alterTableNonKuduOrKuduOnly(); + } + break; + + case 12: + this.enterOuterAlt(_localctx, 12); + { + this.state = 665; + this.addSingleColumn(); + } + break; + + case 13: + this.enterOuterAlt(_localctx, 13); + { + this.state = 666; + this.replaceOrAddColumns(); + } + break; + + case 14: + this.enterOuterAlt(_localctx, 14); + { + this.state = 667; + this.changeColumnDefine(); + } + break; + + case 15: + this.enterOuterAlt(_localctx, 15); + { + this.state = 668; + this.alterStatsKey(); + } + break; + + case 16: + this.enterOuterAlt(_localctx, 16); + { + this.state = 669; + this.alterPartitionCache(); + } + break; + + case 17: + this.enterOuterAlt(_localctx, 17); + { + this.state = 670; + this.alterDropSingleColumn(); + } + break; + + case 18: + this.enterOuterAlt(_localctx, 18); + { + this.state = 671; + this.alterTableOwner(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public alterDatabase(): AlterDatabaseContext { + let _localctx: AlterDatabaseContext = new AlterDatabaseContext(this._ctx, this.state); + this.enterRule(_localctx, 26, ImpalaSqlParser.RULE_alterDatabase); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 674; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 675; + this.match(ImpalaSqlParser.KW_DATABASE); + this.state = 676; + this.databaseNamePath(); + this.state = 677; + this.match(ImpalaSqlParser.KW_SET); + this.state = 678; + this.match(ImpalaSqlParser.KW_OWNER); + this.state = 679; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_ROLE || _la === ImpalaSqlParser.KW_USER)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 680; + this.identifier(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public alterStatsKey(): AlterStatsKeyContext { + let _localctx: AlterStatsKeyContext = new AlterStatsKeyContext(this._ctx, this.state); + this.enterRule(_localctx, 28, ImpalaSqlParser.RULE_alterStatsKey); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 682; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 683; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 684; + this.tableNamePath(); + this.state = 685; + this.match(ImpalaSqlParser.KW_SET); + this.state = 686; + this.match(ImpalaSqlParser.KW_COLUMN); + this.state = 687; + this.match(ImpalaSqlParser.KW_STATS); + this.state = 688; + this.columnNamePath(); + this.state = 689; + this.match(ImpalaSqlParser.LPAREN); + this.state = 690; + this.statsKey(); + this.state = 691; + this.match(ImpalaSqlParser.EQ); + this.state = 692; + this.stringLiteral(); + this.state = 698; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.COMMA) { + { + this.state = 693; + this.match(ImpalaSqlParser.COMMA); + this.state = 694; + this.statsKey(); + this.state = 695; + this.match(ImpalaSqlParser.EQ); + this.state = 696; + this.stringLiteral(); + } + } + + this.state = 700; + this.match(ImpalaSqlParser.RPAREN); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public alterPartitionCache(): AlterPartitionCacheContext { + let _localctx: AlterPartitionCacheContext = new AlterPartitionCacheContext(this._ctx, this.state); + this.enterRule(_localctx, 30, ImpalaSqlParser.RULE_alterPartitionCache); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 702; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 703; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 704; + this.tableNamePath(); + this.state = 707; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PARTITION) { + { + this.state = 705; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 706; + this.expression(); + } + } + + this.state = 709; + this.match(ImpalaSqlParser.KW_SET); + this.state = 720; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_CACHED: + { + { + this.state = 710; + this.match(ImpalaSqlParser.KW_CACHED); + this.state = 711; + this.match(ImpalaSqlParser.KW_IN); + this.state = 712; + this.stringLiteral(); + this.state = 717; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 53, this._ctx) ) { + case 1: + { + this.state = 713; + this.match(ImpalaSqlParser.KW_WITH); + this.state = 714; + this.match(ImpalaSqlParser.KW_REPLICATION); + this.state = 715; + this.match(ImpalaSqlParser.EQ); + this.state = 716; + this.number(); + } + break; + } + } + } + break; + case ImpalaSqlParser.KW_UNCACHED: + { + this.state = 719; + this.match(ImpalaSqlParser.KW_UNCACHED); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public changeColumnDefine(): ChangeColumnDefineContext { + let _localctx: ChangeColumnDefineContext = new ChangeColumnDefineContext(this._ctx, this.state); + this.enterRule(_localctx, 32, ImpalaSqlParser.RULE_changeColumnDefine); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 722; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 723; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 724; + this.tableNamePath(); + this.state = 725; + this.match(ImpalaSqlParser.KW_CHANGE); + this.state = 726; + this.match(ImpalaSqlParser.KW_COLUMN); + this.state = 727; + this.columnSpecWithKudu(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public alterDropSingleColumn(): AlterDropSingleColumnContext { + let _localctx: AlterDropSingleColumnContext = new AlterDropSingleColumnContext(this._ctx, this.state); + this.enterRule(_localctx, 34, ImpalaSqlParser.RULE_alterDropSingleColumn); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 729; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 730; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 731; + this.tableNamePath(); + this.state = 732; + this.match(ImpalaSqlParser.KW_DROP); + this.state = 734; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 55, this._ctx) ) { + case 1: + { + this.state = 733; + this.match(ImpalaSqlParser.KW_COLUMN); + } + break; + } + this.state = 736; + this.columnNamePath(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public alterTableOwner(): AlterTableOwnerContext { + let _localctx: AlterTableOwnerContext = new AlterTableOwnerContext(this._ctx, this.state); + this.enterRule(_localctx, 36, ImpalaSqlParser.RULE_alterTableOwner); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 738; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 739; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 740; + this.tableNamePath(); + this.state = 741; + this.match(ImpalaSqlParser.KW_SET); + this.state = 742; + this.match(ImpalaSqlParser.KW_OWNER); + this.state = 743; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_ROLE || _la === ImpalaSqlParser.KW_USER)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 744; + this.identifier(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public replaceOrAddColumns(): ReplaceOrAddColumnsContext { + let _localctx: ReplaceOrAddColumnsContext = new ReplaceOrAddColumnsContext(this._ctx, this.state); + this.enterRule(_localctx, 38, ImpalaSqlParser.RULE_replaceOrAddColumns); + let _la: number; + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 746; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 747; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 748; + this.tableNamePath(); + this.state = 754; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_REPLACE: + { + this.state = 749; + this.match(ImpalaSqlParser.KW_REPLACE); + } + break; + case ImpalaSqlParser.KW_ADD: + { + this.state = 750; + this.match(ImpalaSqlParser.KW_ADD); + this.state = 752; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_IF) { + { + this.state = 751; + this.ifNotExists(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + this.state = 756; + this.match(ImpalaSqlParser.KW_COLUMNS); + this.state = 757; + this.match(ImpalaSqlParser.LPAREN); + this.state = 758; + this.columnSpecWithKudu(); + this.state = 763; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 58, this._ctx); + while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1 + 1) { + { + { + this.state = 759; + this.match(ImpalaSqlParser.COMMA); + this.state = 760; + this.columnSpecWithKudu(); + } + } + } + this.state = 765; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 58, this._ctx); + } + this.state = 766; + this.match(ImpalaSqlParser.RPAREN); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public addSingleColumn(): AddSingleColumnContext { + let _localctx: AddSingleColumnContext = new AddSingleColumnContext(this._ctx, this.state); + this.enterRule(_localctx, 40, ImpalaSqlParser.RULE_addSingleColumn); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 768; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 769; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 770; + this.tableNamePath(); + this.state = 771; + this.match(ImpalaSqlParser.KW_ADD); + this.state = 772; + this.match(ImpalaSqlParser.KW_COLUMN); + this.state = 774; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 59, this._ctx) ) { + case 1: + { + this.state = 773; + this.ifNotExists(); + } + break; + } + this.state = 776; + this.createColumnSpecWithKudu(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public alterTableNonKuduOrKuduOnly(): AlterTableNonKuduOrKuduOnlyContext { + let _localctx: AlterTableNonKuduOrKuduOnlyContext = new AlterTableNonKuduOrKuduOnlyContext(this._ctx, this.state); + this.enterRule(_localctx, 42, ImpalaSqlParser.RULE_alterTableNonKuduOrKuduOnly); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 778; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 779; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 780; + this.tableNamePath(); + this.state = 781; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 783; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 60, this._ctx) ) { + case 1: + { + this.state = 782; + this.match(ImpalaSqlParser.KW_COLUMN); + } + break; + } + this.state = 785; + this.columnNamePath(); + this.state = 794; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_SET: + { + this.state = 786; + this.match(ImpalaSqlParser.KW_SET); + this.state = 790; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_BLOCK_SIZE: + case ImpalaSqlParser.KW_COMPRESSION: + case ImpalaSqlParser.KW_DEFAULT: + case ImpalaSqlParser.KW_ENCODING: + { + this.state = 787; + this.kuduStorageAttr(); + } + break; + case ImpalaSqlParser.KW_COMMENT: + { + this.state = 788; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 789; + this.stringLiteral(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case ImpalaSqlParser.KW_DROP: + { + this.state = 792; + this.match(ImpalaSqlParser.KW_DROP); + this.state = 793; + this.match(ImpalaSqlParser.KW_DEFAULT); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public addPartitionByRangeOrValue(): AddPartitionByRangeOrValueContext { + let _localctx: AddPartitionByRangeOrValueContext = new AddPartitionByRangeOrValueContext(this._ctx, this.state); + this.enterRule(_localctx, 44, ImpalaSqlParser.RULE_addPartitionByRangeOrValue); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 796; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 797; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 798; + this.tableNamePath(); + this.state = 799; + this.match(ImpalaSqlParser.KW_ADD); + this.state = 801; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_IF) { + { + this.state = 800; + this.ifNotExists(); + } + } + + this.state = 815; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_PARTITION: + { + this.state = 803; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 804; + this.expression(); + this.state = 807; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_LOCATION) { + { + this.state = 805; + this.match(ImpalaSqlParser.KW_LOCATION); + this.state = 806; + this.stringLiteral(); + } + } + + this.state = 810; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_CACHED || _la === ImpalaSqlParser.KW_UNCACHED) { + { + this.state = 809; + this.cacheSpec(); + } + } + + } + break; + case ImpalaSqlParser.KW_RANGE: + { + this.state = 812; + this.match(ImpalaSqlParser.KW_RANGE); + this.state = 813; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 814; + this.kuduPartitionSpec(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public alterFormat(): AlterFormatContext { + let _localctx: AlterFormatContext = new AlterFormatContext(this._ctx, this.state); + this.enterRule(_localctx, 46, ImpalaSqlParser.RULE_alterFormat); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 817; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 818; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 819; + this.tableNamePath(); + this.state = 822; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PARTITION) { + { + this.state = 820; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 821; + this.expression(); + } + } + + this.state = 824; + this.match(ImpalaSqlParser.KW_SET); + this.state = 836; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_FILEFORMAT: + { + { + this.state = 825; + this.match(ImpalaSqlParser.KW_FILEFORMAT); + this.state = 826; + this.fileFormat(); + } + } + break; + case ImpalaSqlParser.KW_ROW: + { + { + this.state = 827; + this.match(ImpalaSqlParser.KW_ROW); + this.state = 828; + this.match(ImpalaSqlParser.KW_FORMAT); + this.state = 829; + this.rowFormat(); + } + } + break; + case ImpalaSqlParser.KW_LOCATION: + { + { + this.state = 830; + this.match(ImpalaSqlParser.KW_LOCATION); + this.state = 831; + this.stringLiteral(); + } + } + break; + case ImpalaSqlParser.KW_TBLPROPERTIES: + { + { + this.state = 832; + this.match(ImpalaSqlParser.KW_TBLPROPERTIES); + this.state = 833; + _localctx._tblProp = this.properties(); + } + } + break; + case ImpalaSqlParser.KW_SERDEPROPERTIES: + { + { + this.state = 834; + this.match(ImpalaSqlParser.KW_SERDEPROPERTIES); + this.state = 835; + _localctx._tblProp = this.properties(); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public recoverPartitions(): RecoverPartitionsContext { + let _localctx: RecoverPartitionsContext = new RecoverPartitionsContext(this._ctx, this.state); + this.enterRule(_localctx, 48, ImpalaSqlParser.RULE_recoverPartitions); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 838; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 839; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 840; + this.tableNamePath(); + this.state = 841; + this.match(ImpalaSqlParser.KW_RECOVER); + this.state = 842; + this.match(ImpalaSqlParser.KW_PARTITIONS); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public dropPartitionByRangeOrValue(): DropPartitionByRangeOrValueContext { + let _localctx: DropPartitionByRangeOrValueContext = new DropPartitionByRangeOrValueContext(this._ctx, this.state); + this.enterRule(_localctx, 50, ImpalaSqlParser.RULE_dropPartitionByRangeOrValue); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 844; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 845; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 846; + this.tableNamePath(); + this.state = 847; + this.match(ImpalaSqlParser.KW_DROP); + this.state = 849; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_IF) { + { + this.state = 848; + this.ifExists(); + } + } + + this.state = 859; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_PARTITION: + { + this.state = 851; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 852; + this.expression(); + this.state = 854; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PURGE) { + { + this.state = 853; + this.match(ImpalaSqlParser.KW_PURGE); + } + } + + } + break; + case ImpalaSqlParser.KW_RANGE: + { + this.state = 856; + this.match(ImpalaSqlParser.KW_RANGE); + this.state = 857; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 858; + this.kuduPartitionSpec(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public alterView(): AlterViewContext { + let _localctx: AlterViewContext = new AlterViewContext(this._ctx, this.state); + this.enterRule(_localctx, 52, ImpalaSqlParser.RULE_alterView); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 861; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 862; + this.match(ImpalaSqlParser.KW_VIEW); + this.state = 863; + this.viewNamePath(); + this.state = 865; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.LPAREN) { + { + this.state = 864; + this.viewColumns(); + } + } + + this.state = 867; + this.match(ImpalaSqlParser.KW_AS); + this.state = 868; + this.queryStatement(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public renameView(): RenameViewContext { + let _localctx: RenameViewContext = new RenameViewContext(this._ctx, this.state); + this.enterRule(_localctx, 54, ImpalaSqlParser.RULE_renameView); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 870; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 871; + this.match(ImpalaSqlParser.KW_VIEW); + this.state = 872; + this.viewNamePath(); + this.state = 873; + this.match(ImpalaSqlParser.KW_RENAME); + this.state = 874; + this.match(ImpalaSqlParser.KW_TO); + this.state = 875; + this.viewNamePath(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public alterViewOwner(): AlterViewOwnerContext { + let _localctx: AlterViewOwnerContext = new AlterViewOwnerContext(this._ctx, this.state); + this.enterRule(_localctx, 56, ImpalaSqlParser.RULE_alterViewOwner); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 877; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 878; + this.match(ImpalaSqlParser.KW_VIEW); + this.state = 879; + this.viewNamePath(); + this.state = 880; + this.match(ImpalaSqlParser.KW_SET); + this.state = 881; + this.match(ImpalaSqlParser.KW_OWNER); + this.state = 882; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_ROLE || _la === ImpalaSqlParser.KW_USER)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 883; + this.qualifiedName(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public renameTable(): RenameTableContext { + let _localctx: RenameTableContext = new RenameTableContext(this._ctx, this.state); + this.enterRule(_localctx, 58, ImpalaSqlParser.RULE_renameTable); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 885; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 886; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 887; + this.tableNamePath(); + this.state = 888; + this.match(ImpalaSqlParser.KW_RENAME); + this.state = 889; + this.match(ImpalaSqlParser.KW_TO); + this.state = 890; + this.tableNamePath(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public alterUnSetOrSetViewTblproperties(): AlterUnSetOrSetViewTblpropertiesContext { + let _localctx: AlterUnSetOrSetViewTblpropertiesContext = new AlterUnSetOrSetViewTblpropertiesContext(this._ctx, this.state); + this.enterRule(_localctx, 60, ImpalaSqlParser.RULE_alterUnSetOrSetViewTblproperties); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 892; + this.match(ImpalaSqlParser.KW_ALTER); + this.state = 893; + this.match(ImpalaSqlParser.KW_VIEW); + this.state = 894; + this.viewNamePath(); + this.state = 895; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_SET || _la === ImpalaSqlParser.KW_UNSET)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 896; + this.match(ImpalaSqlParser.KW_TBLPROPERTIES); + this.state = 897; + _localctx._tblProp = this.properties(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public truncateTableStatement(): TruncateTableStatementContext { + let _localctx: TruncateTableStatementContext = new TruncateTableStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 62, ImpalaSqlParser.RULE_truncateTableStatement); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 899; + this.match(ImpalaSqlParser.KW_TRUNCATE); + this.state = 901; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_TABLE) { + { + this.state = 900; + this.match(ImpalaSqlParser.KW_TABLE); + } + } + + this.state = 904; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 74, this._ctx) ) { + case 1: + { + this.state = 903; + this.ifExists(); + } + break; + } + this.state = 906; + this.tableNamePath(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public describeStatement(): DescribeStatementContext { + let _localctx: DescribeStatementContext = new DescribeStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 64, ImpalaSqlParser.RULE_describeStatement); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 908; + this.match(ImpalaSqlParser.KW_DESCRIBE); + this.state = 910; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 75, this._ctx) ) { + case 1: + { + this.state = 909; + this.match(ImpalaSqlParser.KW_DATABASE); + } + break; + } + this.state = 913; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_EXTENDED || _la === ImpalaSqlParser.KW_FORMATTED) { + { + this.state = 912; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_EXTENDED || _la === ImpalaSqlParser.KW_FORMATTED)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 915; + this.qualifiedName(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public computeStatement(): ComputeStatementContext { + let _localctx: ComputeStatementContext = new ComputeStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 66, ImpalaSqlParser.RULE_computeStatement); + try { + this.state = 919; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 77, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 917; + this.computeStats(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 918; + this.computeIncrementalStats(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public computeStats(): ComputeStatsContext { + let _localctx: ComputeStatsContext = new ComputeStatsContext(this._ctx, this.state); + this.enterRule(_localctx, 68, ImpalaSqlParser.RULE_computeStats); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 921; + this.match(ImpalaSqlParser.KW_COMPUTE); + this.state = 922; + this.match(ImpalaSqlParser.KW_STATS); + this.state = 923; + this.tableNamePath(); + this.state = 925; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 78, this._ctx) ) { + case 1: + { + this.state = 924; + this.columnAliases(); + } + break; + } + this.state = 939; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_TABLESAMPLE) { + { + this.state = 927; + this.match(ImpalaSqlParser.KW_TABLESAMPLE); + this.state = 928; + this.match(ImpalaSqlParser.KW_SYSTEM); + this.state = 929; + this.match(ImpalaSqlParser.LPAREN); + this.state = 930; + this.number(); + this.state = 931; + this.match(ImpalaSqlParser.RPAREN); + this.state = 937; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_REPEATABLE) { + { + this.state = 932; + this.match(ImpalaSqlParser.KW_REPEATABLE); + this.state = 933; + this.match(ImpalaSqlParser.LPAREN); + this.state = 934; + this.number(); + this.state = 935; + this.match(ImpalaSqlParser.RPAREN); + } + } + + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public computeIncrementalStats(): ComputeIncrementalStatsContext { + let _localctx: ComputeIncrementalStatsContext = new ComputeIncrementalStatsContext(this._ctx, this.state); + this.enterRule(_localctx, 70, ImpalaSqlParser.RULE_computeIncrementalStats); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 941; + this.match(ImpalaSqlParser.KW_COMPUTE); + this.state = 942; + this.match(ImpalaSqlParser.KW_INCREMENTAL); + this.state = 943; + this.match(ImpalaSqlParser.KW_STATS); + this.state = 944; + this.tableNamePath(); + this.state = 947; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PARTITION) { + { + this.state = 945; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 946; + this.expression(); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public dropStatement(): DropStatementContext { + let _localctx: DropStatementContext = new DropStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 72, ImpalaSqlParser.RULE_dropStatement); + try { + this.state = 955; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 82, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 949; + this.dropRole(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 950; + this.dropFunction(); + } + break; + + case 3: + this.enterOuterAlt(_localctx, 3); + { + this.state = 951; + this.dropIncrementalStats(); + } + break; + + case 4: + this.enterOuterAlt(_localctx, 4); + { + this.state = 952; + this.dropView(); + } + break; + + case 5: + this.enterOuterAlt(_localctx, 5); + { + this.state = 953; + this.dropTable(); + } + break; + + case 6: + this.enterOuterAlt(_localctx, 6); + { + this.state = 954; + this.dropSchema(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public dropSchema(): DropSchemaContext { + let _localctx: DropSchemaContext = new DropSchemaContext(this._ctx, this.state); + this.enterRule(_localctx, 74, ImpalaSqlParser.RULE_dropSchema); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 957; + this.match(ImpalaSqlParser.KW_DROP); + this.state = 958; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_DATABASE || _la === ImpalaSqlParser.KW_SCHEMA)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 960; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 83, this._ctx) ) { + case 1: + { + this.state = 959; + this.ifExists(); + } + break; + } + this.state = 962; + this.databaseNamePath(); + this.state = 964; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_CASCADE || _la === ImpalaSqlParser.KW_RESTRICT) { + { + this.state = 963; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_CASCADE || _la === ImpalaSqlParser.KW_RESTRICT)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public dropView(): DropViewContext { + let _localctx: DropViewContext = new DropViewContext(this._ctx, this.state); + this.enterRule(_localctx, 76, ImpalaSqlParser.RULE_dropView); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 966; + this.match(ImpalaSqlParser.KW_DROP); + this.state = 967; + this.match(ImpalaSqlParser.KW_VIEW); + this.state = 969; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 85, this._ctx) ) { + case 1: + { + this.state = 968; + this.ifExists(); + } + break; + } + this.state = 971; + this.viewNamePath(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public dropTable(): DropTableContext { + let _localctx: DropTableContext = new DropTableContext(this._ctx, this.state); + this.enterRule(_localctx, 78, ImpalaSqlParser.RULE_dropTable); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 973; + this.match(ImpalaSqlParser.KW_DROP); + this.state = 974; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 976; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 86, this._ctx) ) { + case 1: + { + this.state = 975; + this.ifExists(); + } + break; + } + this.state = 978; + this.tableNamePath(); + this.state = 980; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PURGE) { + { + this.state = 979; + this.match(ImpalaSqlParser.KW_PURGE); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public dropIncrementalStats(): DropIncrementalStatsContext { + let _localctx: DropIncrementalStatsContext = new DropIncrementalStatsContext(this._ctx, this.state); + this.enterRule(_localctx, 80, ImpalaSqlParser.RULE_dropIncrementalStats); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 982; + this.match(ImpalaSqlParser.KW_DROP); + this.state = 984; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_INCREMENTAL) { + { + this.state = 983; + this.match(ImpalaSqlParser.KW_INCREMENTAL); + } + } + + this.state = 986; + this.match(ImpalaSqlParser.KW_STATS); + this.state = 987; + this.tableNamePath(); + this.state = 990; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PARTITION) { + { + this.state = 988; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 989; + this.expression(); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public dropFunction(): DropFunctionContext { + let _localctx: DropFunctionContext = new DropFunctionContext(this._ctx, this.state); + this.enterRule(_localctx, 82, ImpalaSqlParser.RULE_dropFunction); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 992; + this.match(ImpalaSqlParser.KW_DROP); + this.state = 994; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_AGGREGATE) { + { + this.state = 993; + this.match(ImpalaSqlParser.KW_AGGREGATE); + } + } + + this.state = 996; + this.match(ImpalaSqlParser.KW_FUNCTION); + this.state = 998; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 91, this._ctx) ) { + case 1: + { + this.state = 997; + this.ifExists(); + } + break; + } + this.state = 1000; + this.functionNamePath(); + this.state = 1013; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 94, this._ctx) ) { + case 1: + { + this.state = 1001; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1010; + this._errHandler.sync(this); + _la = this._input.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ImpalaSqlParser.KW_ADD) | (1 << ImpalaSqlParser.KW_ALL) | (1 << ImpalaSqlParser.KW_ANY) | (1 << ImpalaSqlParser.KW_ARRAY) | (1 << ImpalaSqlParser.KW_ASC) | (1 << ImpalaSqlParser.KW_AT) | (1 << ImpalaSqlParser.KW_BERNOULLI) | (1 << ImpalaSqlParser.KW_CASCADE))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (ImpalaSqlParser.KW_COLUMN - 32)) | (1 << (ImpalaSqlParser.KW_COLUMNS - 32)) | (1 << (ImpalaSqlParser.KW_COMMENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT - 32)) | (1 << (ImpalaSqlParser.KW_DATA - 32)) | (1 << (ImpalaSqlParser.KW_DATABASE - 32)) | (1 << (ImpalaSqlParser.KW_DATABASES - 32)) | (1 << (ImpalaSqlParser.KW_DAY - 32)) | (1 << (ImpalaSqlParser.KW_DAYS - 32)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 32)) | (1 << (ImpalaSqlParser.KW_DESC - 32)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (ImpalaSqlParser.KW_EXCLUDING - 65)) | (1 << (ImpalaSqlParser.KW_EXPLAIN - 65)) | (1 << (ImpalaSqlParser.KW_FILTER - 65)) | (1 << (ImpalaSqlParser.KW_FIRST - 65)) | (1 << (ImpalaSqlParser.KW_FOLLOWING - 65)) | (1 << (ImpalaSqlParser.KW_FORMAT - 65)) | (1 << (ImpalaSqlParser.KW_FUNCTIONS - 65)) | (1 << (ImpalaSqlParser.KW_GRANT - 65)) | (1 << (ImpalaSqlParser.KW_HOUR - 65)) | (1 << (ImpalaSqlParser.KW_IF - 65)) | (1 << (ImpalaSqlParser.KW_INCLUDING - 65)))) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (ImpalaSqlParser.KW_INTERVAL - 101)) | (1 << (ImpalaSqlParser.KW_LAST - 101)) | (1 << (ImpalaSqlParser.KW_LATERAL - 101)) | (1 << (ImpalaSqlParser.KW_LIMIT - 101)) | (1 << (ImpalaSqlParser.KW_MAP - 101)) | (1 << (ImpalaSqlParser.KW_MINUTE - 101)) | (1 << (ImpalaSqlParser.KW_MONTH - 101)) | (1 << (ImpalaSqlParser.KW_NFC - 101)) | (1 << (ImpalaSqlParser.KW_NFD - 101)) | (1 << (ImpalaSqlParser.KW_NFKC - 101)) | (1 << (ImpalaSqlParser.KW_NFKD - 101)))) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & ((1 << (ImpalaSqlParser.KW_NULLS - 133)) | (1 << (ImpalaSqlParser.KW_OFFSET - 133)) | (1 << (ImpalaSqlParser.KW_OPTION - 133)) | (1 << (ImpalaSqlParser.KW_ORDINALITY - 133)) | (1 << (ImpalaSqlParser.KW_OVER - 133)) | (1 << (ImpalaSqlParser.KW_PARTITION - 133)) | (1 << (ImpalaSqlParser.KW_PARTITIONS - 133)) | (1 << (ImpalaSqlParser.KW_PARQUET - 133)) | (1 << (ImpalaSqlParser.KW_POSITION - 133)) | (1 << (ImpalaSqlParser.KW_PRECEDING - 133)) | (1 << (ImpalaSqlParser.KW_PRIVILEGES - 133)) | (1 << (ImpalaSqlParser.KW_PROPERTIES - 133)) | (1 << (ImpalaSqlParser.KW_RANGE - 133)) | (1 << (ImpalaSqlParser.KW_RENAME - 133)) | (1 << (ImpalaSqlParser.KW_REPEATABLE - 133)) | (1 << (ImpalaSqlParser.KW_REPLACE - 133)) | (1 << (ImpalaSqlParser.KW_RESTRICT - 133)) | (1 << (ImpalaSqlParser.KW_REVOKE - 133)))) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & ((1 << (ImpalaSqlParser.KW_ROLE - 165)) | (1 << (ImpalaSqlParser.KW_ROLES - 165)) | (1 << (ImpalaSqlParser.KW_ROW - 165)) | (1 << (ImpalaSqlParser.KW_ROWS - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMA - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMAS - 165)) | (1 << (ImpalaSqlParser.KW_SECOND - 165)) | (1 << (ImpalaSqlParser.KW_SECONDS - 165)) | (1 << (ImpalaSqlParser.KW_SET - 165)) | (1 << (ImpalaSqlParser.KW_SHOW - 165)) | (1 << (ImpalaSqlParser.KW_SOME - 165)) | (1 << (ImpalaSqlParser.KW_STATS - 165)) | (1 << (ImpalaSqlParser.KW_STRUCT - 165)) | (1 << (ImpalaSqlParser.KW_SUBSTRING - 165)) | (1 << (ImpalaSqlParser.KW_SYSTEM - 165)) | (1 << (ImpalaSqlParser.KW_TABLES - 165)) | (1 << (ImpalaSqlParser.KW_TABLESAMPLE - 165)) | (1 << (ImpalaSqlParser.KW_TO - 165)) | (1 << (ImpalaSqlParser.KW_TRY_CAST - 165)) | (1 << (ImpalaSqlParser.KW_TRUNCATE - 165)))) !== 0) || ((((_la - 199)) & ~0x1F) === 0 && ((1 << (_la - 199)) & ((1 << (ImpalaSqlParser.KW_UNBOUNDED - 199)) | (1 << (ImpalaSqlParser.KW_USE - 199)) | (1 << (ImpalaSqlParser.KW_USER - 199)) | (1 << (ImpalaSqlParser.KW_VIEW - 199)) | (1 << (ImpalaSqlParser.KW_VIEWS - 199)) | (1 << (ImpalaSqlParser.KW_YEAR - 199)) | (1 << (ImpalaSqlParser.KW_TEXTFILE - 199)) | (1 << (ImpalaSqlParser.KW_ORC - 199)) | (1 << (ImpalaSqlParser.KW_AVRO - 199)) | (1 << (ImpalaSqlParser.KW_SEQUENCEFILE - 199)) | (1 << (ImpalaSqlParser.KW_RCFILE - 199)))) !== 0) || ((((_la - 255)) & ~0x1F) === 0 && ((1 << (_la - 255)) & ((1 << (ImpalaSqlParser.STRING - 255)) | (1 << (ImpalaSqlParser.IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.DIGIT_IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.BACKQUOTED_IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.TIME_WITH_TIME_ZONE - 255)) | (1 << (ImpalaSqlParser.TIMESTAMP_WITH_TIME_ZONE - 255)) | (1 << (ImpalaSqlParser.DOUBLE_PRECISION - 255)))) !== 0)) { + { + this.state = 1002; + this.type(0); + this.state = 1007; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 1003; + this.match(ImpalaSqlParser.COMMA); + this.state = 1004; + this.type(0); + } + } + this.state = 1009; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + this.state = 1012; + this.match(ImpalaSqlParser.RPAREN); + } + break; + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public dropRole(): DropRoleContext { + let _localctx: DropRoleContext = new DropRoleContext(this._ctx, this.state); + this.enterRule(_localctx, 84, ImpalaSqlParser.RULE_dropRole); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1015; + this.match(ImpalaSqlParser.KW_DROP); + this.state = 1016; + this.match(ImpalaSqlParser.KW_ROLE); + this.state = 1017; + _localctx._name = this.identifier(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public grantStatement(): GrantStatementContext { + let _localctx: GrantStatementContext = new GrantStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 86, ImpalaSqlParser.RULE_grantStatement); + try { + this.state = 1021; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 95, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 1019; + this.grantRole(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1020; + this.grant(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public grantRole(): GrantRoleContext { + let _localctx: GrantRoleContext = new GrantRoleContext(this._ctx, this.state); + this.enterRule(_localctx, 88, ImpalaSqlParser.RULE_grantRole); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1023; + this.match(ImpalaSqlParser.KW_GRANT); + this.state = 1024; + this.match(ImpalaSqlParser.KW_ROLE); + this.state = 1025; + this.identifier(); + this.state = 1026; + this.match(ImpalaSqlParser.KW_TO); + this.state = 1027; + this.match(ImpalaSqlParser.KW_GROUP); + this.state = 1028; + this.identifier(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public grant(): GrantContext { + let _localctx: GrantContext = new GrantContext(this._ctx, this.state); + this.enterRule(_localctx, 90, ImpalaSqlParser.RULE_grant); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1030; + this.match(ImpalaSqlParser.KW_GRANT); + this.state = 1031; + this.privilege(); + this.state = 1032; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1033; + this.objectType(); + this.state = 1035; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 96, this._ctx) ) { + case 1: + { + this.state = 1034; + this.qualifiedName(); + } + break; + } + this.state = 1037; + this.match(ImpalaSqlParser.KW_TO); + this.state = 1038; + _localctx._grantee = this.principal(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public revokeStatement(): RevokeStatementContext { + let _localctx: RevokeStatementContext = new RevokeStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 92, ImpalaSqlParser.RULE_revokeStatement); + try { + this.state = 1042; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 97, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 1040; + this.revokeRole(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1041; + this.revoke(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public revokeRole(): RevokeRoleContext { + let _localctx: RevokeRoleContext = new RevokeRoleContext(this._ctx, this.state); + this.enterRule(_localctx, 94, ImpalaSqlParser.RULE_revokeRole); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1044; + this.match(ImpalaSqlParser.KW_REVOKE); + this.state = 1045; + this.match(ImpalaSqlParser.KW_ROLE); + this.state = 1046; + this.identifier(); + this.state = 1047; + this.match(ImpalaSqlParser.KW_FROM); + this.state = 1048; + this.match(ImpalaSqlParser.KW_GROUP); + this.state = 1049; + this.identifier(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public revoke(): RevokeContext { + let _localctx: RevokeContext = new RevokeContext(this._ctx, this.state); + this.enterRule(_localctx, 96, ImpalaSqlParser.RULE_revoke); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1051; + this.match(ImpalaSqlParser.KW_REVOKE); + this.state = 1055; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_GRANT) { + { + this.state = 1052; + this.match(ImpalaSqlParser.KW_GRANT); + this.state = 1053; + this.match(ImpalaSqlParser.KW_OPTION); + this.state = 1054; + this.match(ImpalaSqlParser.KW_FOR); + } + } + + this.state = 1057; + this.privilege(); + this.state = 1058; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1059; + this.objectType(); + this.state = 1061; + this._errHandler.sync(this); + _la = this._input.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ImpalaSqlParser.KW_ADD) | (1 << ImpalaSqlParser.KW_ALL) | (1 << ImpalaSqlParser.KW_ANY) | (1 << ImpalaSqlParser.KW_ARRAY) | (1 << ImpalaSqlParser.KW_ASC) | (1 << ImpalaSqlParser.KW_AT) | (1 << ImpalaSqlParser.KW_BERNOULLI) | (1 << ImpalaSqlParser.KW_CASCADE))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (ImpalaSqlParser.KW_COLUMN - 32)) | (1 << (ImpalaSqlParser.KW_COLUMNS - 32)) | (1 << (ImpalaSqlParser.KW_COMMENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT - 32)) | (1 << (ImpalaSqlParser.KW_DATA - 32)) | (1 << (ImpalaSqlParser.KW_DATABASE - 32)) | (1 << (ImpalaSqlParser.KW_DATABASES - 32)) | (1 << (ImpalaSqlParser.KW_DAY - 32)) | (1 << (ImpalaSqlParser.KW_DAYS - 32)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 32)) | (1 << (ImpalaSqlParser.KW_DESC - 32)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (ImpalaSqlParser.KW_EXCLUDING - 65)) | (1 << (ImpalaSqlParser.KW_EXPLAIN - 65)) | (1 << (ImpalaSqlParser.KW_FILTER - 65)) | (1 << (ImpalaSqlParser.KW_FIRST - 65)) | (1 << (ImpalaSqlParser.KW_FOLLOWING - 65)) | (1 << (ImpalaSqlParser.KW_FORMAT - 65)) | (1 << (ImpalaSqlParser.KW_FUNCTIONS - 65)) | (1 << (ImpalaSqlParser.KW_GRANT - 65)) | (1 << (ImpalaSqlParser.KW_HOUR - 65)) | (1 << (ImpalaSqlParser.KW_IF - 65)) | (1 << (ImpalaSqlParser.KW_INCLUDING - 65)))) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (ImpalaSqlParser.KW_INTERVAL - 101)) | (1 << (ImpalaSqlParser.KW_LAST - 101)) | (1 << (ImpalaSqlParser.KW_LATERAL - 101)) | (1 << (ImpalaSqlParser.KW_LIMIT - 101)) | (1 << (ImpalaSqlParser.KW_MAP - 101)) | (1 << (ImpalaSqlParser.KW_MINUTE - 101)) | (1 << (ImpalaSqlParser.KW_MONTH - 101)) | (1 << (ImpalaSqlParser.KW_NFC - 101)) | (1 << (ImpalaSqlParser.KW_NFD - 101)) | (1 << (ImpalaSqlParser.KW_NFKC - 101)) | (1 << (ImpalaSqlParser.KW_NFKD - 101)))) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & ((1 << (ImpalaSqlParser.KW_NULLS - 133)) | (1 << (ImpalaSqlParser.KW_OFFSET - 133)) | (1 << (ImpalaSqlParser.KW_OPTION - 133)) | (1 << (ImpalaSqlParser.KW_ORDINALITY - 133)) | (1 << (ImpalaSqlParser.KW_OVER - 133)) | (1 << (ImpalaSqlParser.KW_PARTITION - 133)) | (1 << (ImpalaSqlParser.KW_PARTITIONS - 133)) | (1 << (ImpalaSqlParser.KW_PARQUET - 133)) | (1 << (ImpalaSqlParser.KW_POSITION - 133)) | (1 << (ImpalaSqlParser.KW_PRECEDING - 133)) | (1 << (ImpalaSqlParser.KW_PRIVILEGES - 133)) | (1 << (ImpalaSqlParser.KW_PROPERTIES - 133)) | (1 << (ImpalaSqlParser.KW_RANGE - 133)) | (1 << (ImpalaSqlParser.KW_RENAME - 133)) | (1 << (ImpalaSqlParser.KW_REPEATABLE - 133)) | (1 << (ImpalaSqlParser.KW_REPLACE - 133)) | (1 << (ImpalaSqlParser.KW_RESTRICT - 133)) | (1 << (ImpalaSqlParser.KW_REVOKE - 133)))) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & ((1 << (ImpalaSqlParser.KW_ROLE - 165)) | (1 << (ImpalaSqlParser.KW_ROLES - 165)) | (1 << (ImpalaSqlParser.KW_ROW - 165)) | (1 << (ImpalaSqlParser.KW_ROWS - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMA - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMAS - 165)) | (1 << (ImpalaSqlParser.KW_SECOND - 165)) | (1 << (ImpalaSqlParser.KW_SECONDS - 165)) | (1 << (ImpalaSqlParser.KW_SET - 165)) | (1 << (ImpalaSqlParser.KW_SHOW - 165)) | (1 << (ImpalaSqlParser.KW_SOME - 165)) | (1 << (ImpalaSqlParser.KW_STATS - 165)) | (1 << (ImpalaSqlParser.KW_SUBSTRING - 165)) | (1 << (ImpalaSqlParser.KW_SYSTEM - 165)) | (1 << (ImpalaSqlParser.KW_TABLES - 165)) | (1 << (ImpalaSqlParser.KW_TABLESAMPLE - 165)) | (1 << (ImpalaSqlParser.KW_TO - 165)) | (1 << (ImpalaSqlParser.KW_TRY_CAST - 165)) | (1 << (ImpalaSqlParser.KW_TRUNCATE - 165)))) !== 0) || ((((_la - 199)) & ~0x1F) === 0 && ((1 << (_la - 199)) & ((1 << (ImpalaSqlParser.KW_UNBOUNDED - 199)) | (1 << (ImpalaSqlParser.KW_USE - 199)) | (1 << (ImpalaSqlParser.KW_USER - 199)) | (1 << (ImpalaSqlParser.KW_VIEW - 199)) | (1 << (ImpalaSqlParser.KW_VIEWS - 199)) | (1 << (ImpalaSqlParser.KW_YEAR - 199)) | (1 << (ImpalaSqlParser.KW_TEXTFILE - 199)) | (1 << (ImpalaSqlParser.KW_ORC - 199)) | (1 << (ImpalaSqlParser.KW_AVRO - 199)) | (1 << (ImpalaSqlParser.KW_SEQUENCEFILE - 199)) | (1 << (ImpalaSqlParser.KW_RCFILE - 199)))) !== 0) || ((((_la - 255)) & ~0x1F) === 0 && ((1 << (_la - 255)) & ((1 << (ImpalaSqlParser.STRING - 255)) | (1 << (ImpalaSqlParser.IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.DIGIT_IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.BACKQUOTED_IDENTIFIER - 255)))) !== 0)) { + { + this.state = 1060; + this.qualifiedName(); + } + } + + this.state = 1063; + this.match(ImpalaSqlParser.KW_FROM); + this.state = 1069; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 101, this._ctx) ) { + case 1: + { + this.state = 1064; + _localctx._grantee = this.principal(); + } + break; + + case 2: + { + this.state = 1066; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 100, this._ctx) ) { + case 1: + { + this.state = 1065; + this.match(ImpalaSqlParser.KW_ROLE); + } + break; + } + this.state = 1068; + this.identifier(); + } + break; + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public insertStatement(): InsertStatementContext { + let _localctx: InsertStatementContext = new InsertStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 98, ImpalaSqlParser.RULE_insertStatement); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1072; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_WITH) { + { + this.state = 1071; + this.with(); + } + } + + this.state = 1074; + this.match(ImpalaSqlParser.KW_INSERT); + this.state = 1075; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_INTO || _la === ImpalaSqlParser.KW_OVERWRITE)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1077; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_TABLE) { + { + this.state = 1076; + this.match(ImpalaSqlParser.KW_TABLE); + } + } + + this.state = 1079; + this.tableNamePath(); + this.state = 1081; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 104, this._ctx) ) { + case 1: + { + this.state = 1080; + this.columnAliases(); + } + break; + } + this.state = 1095; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PARTITION) { + { + this.state = 1083; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 1084; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1085; + this.expression(); + this.state = 1090; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 1086; + this.match(ImpalaSqlParser.COMMA); + this.state = 1087; + this.expression(); + } + } + this.state = 1092; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 1093; + this.match(ImpalaSqlParser.RPAREN); + } + } + + this.state = 1097; + this.queryStatement(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public deleteStatement(): DeleteStatementContext { + let _localctx: DeleteStatementContext = new DeleteStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 100, ImpalaSqlParser.RULE_deleteStatement); + try { + this.state = 1101; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 107, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 1099; + this.delete(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1100; + this.deleteTableRef(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public delete(): DeleteContext { + let _localctx: DeleteContext = new DeleteContext(this._ctx, this.state); + this.enterRule(_localctx, 102, ImpalaSqlParser.RULE_delete); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1103; + this.match(ImpalaSqlParser.KW_DELETE); + this.state = 1105; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_FROM) { + { + this.state = 1104; + this.match(ImpalaSqlParser.KW_FROM); + } + } + + this.state = 1107; + this.tableNamePath(); + this.state = 1110; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_WHERE) { + { + this.state = 1108; + this.match(ImpalaSqlParser.KW_WHERE); + this.state = 1109; + this.booleanExpression(0); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public deleteTableRef(): DeleteTableRefContext { + let _localctx: DeleteTableRefContext = new DeleteTableRefContext(this._ctx, this.state); + this.enterRule(_localctx, 104, ImpalaSqlParser.RULE_deleteTableRef); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1112; + this.match(ImpalaSqlParser.KW_DELETE); + this.state = 1113; + this.tableNamePath(); + this.state = 1118; + this._errHandler.sync(this); + _la = this._input.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ImpalaSqlParser.KW_ADD) | (1 << ImpalaSqlParser.KW_ALL) | (1 << ImpalaSqlParser.KW_ANY) | (1 << ImpalaSqlParser.KW_ARRAY) | (1 << ImpalaSqlParser.KW_AS) | (1 << ImpalaSqlParser.KW_ASC) | (1 << ImpalaSqlParser.KW_AT) | (1 << ImpalaSqlParser.KW_BERNOULLI) | (1 << ImpalaSqlParser.KW_CASCADE))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (ImpalaSqlParser.KW_COLUMN - 32)) | (1 << (ImpalaSqlParser.KW_COLUMNS - 32)) | (1 << (ImpalaSqlParser.KW_COMMENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT - 32)) | (1 << (ImpalaSqlParser.KW_DATA - 32)) | (1 << (ImpalaSqlParser.KW_DATABASE - 32)) | (1 << (ImpalaSqlParser.KW_DATABASES - 32)) | (1 << (ImpalaSqlParser.KW_DAY - 32)) | (1 << (ImpalaSqlParser.KW_DAYS - 32)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 32)) | (1 << (ImpalaSqlParser.KW_DESC - 32)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (ImpalaSqlParser.KW_EXCLUDING - 65)) | (1 << (ImpalaSqlParser.KW_EXPLAIN - 65)) | (1 << (ImpalaSqlParser.KW_FILTER - 65)) | (1 << (ImpalaSqlParser.KW_FIRST - 65)) | (1 << (ImpalaSqlParser.KW_FOLLOWING - 65)) | (1 << (ImpalaSqlParser.KW_FORMAT - 65)) | (1 << (ImpalaSqlParser.KW_FUNCTIONS - 65)) | (1 << (ImpalaSqlParser.KW_GRANT - 65)) | (1 << (ImpalaSqlParser.KW_HOUR - 65)) | (1 << (ImpalaSqlParser.KW_IF - 65)) | (1 << (ImpalaSqlParser.KW_INCLUDING - 65)))) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (ImpalaSqlParser.KW_INTERVAL - 101)) | (1 << (ImpalaSqlParser.KW_LAST - 101)) | (1 << (ImpalaSqlParser.KW_LATERAL - 101)) | (1 << (ImpalaSqlParser.KW_LIMIT - 101)) | (1 << (ImpalaSqlParser.KW_MAP - 101)) | (1 << (ImpalaSqlParser.KW_MINUTE - 101)) | (1 << (ImpalaSqlParser.KW_MONTH - 101)) | (1 << (ImpalaSqlParser.KW_NFC - 101)) | (1 << (ImpalaSqlParser.KW_NFD - 101)) | (1 << (ImpalaSqlParser.KW_NFKC - 101)) | (1 << (ImpalaSqlParser.KW_NFKD - 101)))) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & ((1 << (ImpalaSqlParser.KW_NULLS - 133)) | (1 << (ImpalaSqlParser.KW_OFFSET - 133)) | (1 << (ImpalaSqlParser.KW_OPTION - 133)) | (1 << (ImpalaSqlParser.KW_ORDINALITY - 133)) | (1 << (ImpalaSqlParser.KW_OVER - 133)) | (1 << (ImpalaSqlParser.KW_PARTITION - 133)) | (1 << (ImpalaSqlParser.KW_PARTITIONS - 133)) | (1 << (ImpalaSqlParser.KW_PARQUET - 133)) | (1 << (ImpalaSqlParser.KW_POSITION - 133)) | (1 << (ImpalaSqlParser.KW_PRECEDING - 133)) | (1 << (ImpalaSqlParser.KW_PRIVILEGES - 133)) | (1 << (ImpalaSqlParser.KW_PROPERTIES - 133)) | (1 << (ImpalaSqlParser.KW_RANGE - 133)) | (1 << (ImpalaSqlParser.KW_RENAME - 133)) | (1 << (ImpalaSqlParser.KW_REPEATABLE - 133)) | (1 << (ImpalaSqlParser.KW_REPLACE - 133)) | (1 << (ImpalaSqlParser.KW_RESTRICT - 133)) | (1 << (ImpalaSqlParser.KW_REVOKE - 133)))) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & ((1 << (ImpalaSqlParser.KW_ROLE - 165)) | (1 << (ImpalaSqlParser.KW_ROLES - 165)) | (1 << (ImpalaSqlParser.KW_ROW - 165)) | (1 << (ImpalaSqlParser.KW_ROWS - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMA - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMAS - 165)) | (1 << (ImpalaSqlParser.KW_SECOND - 165)) | (1 << (ImpalaSqlParser.KW_SECONDS - 165)) | (1 << (ImpalaSqlParser.KW_SET - 165)) | (1 << (ImpalaSqlParser.KW_SHOW - 165)) | (1 << (ImpalaSqlParser.KW_SOME - 165)) | (1 << (ImpalaSqlParser.KW_STATS - 165)) | (1 << (ImpalaSqlParser.KW_SUBSTRING - 165)) | (1 << (ImpalaSqlParser.KW_SYSTEM - 165)) | (1 << (ImpalaSqlParser.KW_TABLES - 165)) | (1 << (ImpalaSqlParser.KW_TABLESAMPLE - 165)) | (1 << (ImpalaSqlParser.KW_TO - 165)) | (1 << (ImpalaSqlParser.KW_TRY_CAST - 165)) | (1 << (ImpalaSqlParser.KW_TRUNCATE - 165)))) !== 0) || ((((_la - 199)) & ~0x1F) === 0 && ((1 << (_la - 199)) & ((1 << (ImpalaSqlParser.KW_UNBOUNDED - 199)) | (1 << (ImpalaSqlParser.KW_USE - 199)) | (1 << (ImpalaSqlParser.KW_USER - 199)) | (1 << (ImpalaSqlParser.KW_VIEW - 199)) | (1 << (ImpalaSqlParser.KW_VIEWS - 199)) | (1 << (ImpalaSqlParser.KW_YEAR - 199)) | (1 << (ImpalaSqlParser.KW_TEXTFILE - 199)) | (1 << (ImpalaSqlParser.KW_ORC - 199)) | (1 << (ImpalaSqlParser.KW_AVRO - 199)) | (1 << (ImpalaSqlParser.KW_SEQUENCEFILE - 199)) | (1 << (ImpalaSqlParser.KW_RCFILE - 199)))) !== 0) || ((((_la - 255)) & ~0x1F) === 0 && ((1 << (_la - 255)) & ((1 << (ImpalaSqlParser.STRING - 255)) | (1 << (ImpalaSqlParser.IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.DIGIT_IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.BACKQUOTED_IDENTIFIER - 255)))) !== 0)) { + { + this.state = 1115; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_AS) { + { + this.state = 1114; + this.match(ImpalaSqlParser.KW_AS); + } + } + + this.state = 1117; + this.identifier(); + } + } + + this.state = 1120; + this.match(ImpalaSqlParser.KW_FROM); + this.state = 1129; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 113, this._ctx) ) { + case 1: + { + this.state = 1121; + this.relation(0); + this.state = 1126; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 1122; + this.match(ImpalaSqlParser.COMMA); + this.state = 1123; + this.relation(0); + } + } + this.state = 1128; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + break; + } + this.state = 1133; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_WHERE) { + { + this.state = 1131; + this.match(ImpalaSqlParser.KW_WHERE); + this.state = 1132; + this.booleanExpression(0); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public updateStatement(): UpdateStatementContext { + let _localctx: UpdateStatementContext = new UpdateStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 106, ImpalaSqlParser.RULE_updateStatement); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1135; + this.match(ImpalaSqlParser.KW_UPDATE); + this.state = 1136; + this.tableNamePath(); + this.state = 1137; + this.match(ImpalaSqlParser.KW_SET); + this.state = 1138; + this.assignmentList(); + this.state = 1148; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_FROM) { + { + this.state = 1139; + this.match(ImpalaSqlParser.KW_FROM); + this.state = 1140; + this.relation(0); + this.state = 1145; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 1141; + this.match(ImpalaSqlParser.COMMA); + this.state = 1142; + this.relation(0); + } + } + this.state = 1147; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + this.state = 1152; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_WHERE) { + { + this.state = 1150; + this.match(ImpalaSqlParser.KW_WHERE); + this.state = 1151; + this.booleanExpression(0); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public upsertStatement(): UpsertStatementContext { + let _localctx: UpsertStatementContext = new UpsertStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 108, ImpalaSqlParser.RULE_upsertStatement); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1154; + this.match(ImpalaSqlParser.KW_UPSERT); + this.state = 1155; + this.match(ImpalaSqlParser.KW_INTO); + this.state = 1157; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_TABLE) { + { + this.state = 1156; + this.match(ImpalaSqlParser.KW_TABLE); + } + } + + this.state = 1159; + this.tableNamePath(); + this.state = 1161; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 119, this._ctx) ) { + case 1: + { + this.state = 1160; + this.columnAliases(); + } + break; + } + this.state = 1163; + this.queryStatement(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showStatement(): ShowStatementContext { + let _localctx: ShowStatementContext = new ShowStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 110, ImpalaSqlParser.RULE_showStatement); + try { + this.state = 1177; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 120, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 1165; + this.showRoles(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1166; + this.showRoleGrant(); + } + break; + + case 3: + this.enterOuterAlt(_localctx, 3); + { + this.state = 1167; + this.showGrants(); + } + break; + + case 4: + this.enterOuterAlt(_localctx, 4); + { + this.state = 1168; + this.showFiles(); + } + break; + + case 5: + this.enterOuterAlt(_localctx, 5); + { + this.state = 1169; + this.showPartitions(); + } + break; + + case 6: + this.enterOuterAlt(_localctx, 6); + { + this.state = 1170; + this.showColumnStats(); + } + break; + + case 7: + this.enterOuterAlt(_localctx, 7); + { + this.state = 1171; + this.showTableStats(); + } + break; + + case 8: + this.enterOuterAlt(_localctx, 8); + { + this.state = 1172; + this.showCreateView(); + } + break; + + case 9: + this.enterOuterAlt(_localctx, 9); + { + this.state = 1173; + this.showCreateTable(); + } + break; + + case 10: + this.enterOuterAlt(_localctx, 10); + { + this.state = 1174; + this.showFunctions(); + } + break; + + case 11: + this.enterOuterAlt(_localctx, 11); + { + this.state = 1175; + this.showTables(); + } + break; + + case 12: + this.enterOuterAlt(_localctx, 12); + { + this.state = 1176; + this.showSchemas(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showSchemas(): ShowSchemasContext { + let _localctx: ShowSchemasContext = new ShowSchemasContext(this._ctx, this.state); + this.enterRule(_localctx, 112, ImpalaSqlParser.RULE_showSchemas); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1179; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1180; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_DATABASES || _la === ImpalaSqlParser.KW_SCHEMAS)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1192; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_LIKE || _la === ImpalaSqlParser.STRING || _la === ImpalaSqlParser.UNICODE_STRING) { + { + this.state = 1182; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_LIKE) { + { + this.state = 1181; + this.match(ImpalaSqlParser.KW_LIKE); + } + } + + this.state = 1184; + _localctx._pattern = this.stringLiteral(); + this.state = 1189; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.BITWISEOR) { + { + { + this.state = 1185; + this.match(ImpalaSqlParser.BITWISEOR); + this.state = 1186; + this.stringLiteral(); + } + } + this.state = 1191; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showTables(): ShowTablesContext { + let _localctx: ShowTablesContext = new ShowTablesContext(this._ctx, this.state); + this.enterRule(_localctx, 114, ImpalaSqlParser.RULE_showTables); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1194; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1195; + this.match(ImpalaSqlParser.KW_TABLES); + this.state = 1198; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_IN) { + { + this.state = 1196; + this.match(ImpalaSqlParser.KW_IN); + this.state = 1197; + this.tableNamePath(); + } + } + + this.state = 1211; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_LIKE || _la === ImpalaSqlParser.STRING || _la === ImpalaSqlParser.UNICODE_STRING) { + { + this.state = 1201; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_LIKE) { + { + this.state = 1200; + this.match(ImpalaSqlParser.KW_LIKE); + } + } + + this.state = 1203; + _localctx._pattern = this.stringLiteral(); + this.state = 1208; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.BITWISEOR) { + { + { + this.state = 1204; + this.match(ImpalaSqlParser.BITWISEOR); + this.state = 1205; + this.stringLiteral(); + } + } + this.state = 1210; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showFunctions(): ShowFunctionsContext { + let _localctx: ShowFunctionsContext = new ShowFunctionsContext(this._ctx, this.state); + this.enterRule(_localctx, 116, ImpalaSqlParser.RULE_showFunctions); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1213; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1215; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ANALYTIC || _la === ImpalaSqlParser.KW_AGGREGATE) { + { + this.state = 1214; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_ANALYTIC || _la === ImpalaSqlParser.KW_AGGREGATE)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 1217; + this.match(ImpalaSqlParser.KW_FUNCTIONS); + this.state = 1220; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_IN) { + { + this.state = 1218; + this.match(ImpalaSqlParser.KW_IN); + this.state = 1219; + this.databaseNamePath(); + } + } + + this.state = 1233; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_LIKE || _la === ImpalaSqlParser.STRING || _la === ImpalaSqlParser.UNICODE_STRING) { + { + this.state = 1223; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_LIKE) { + { + this.state = 1222; + this.match(ImpalaSqlParser.KW_LIKE); + } + } + + this.state = 1225; + _localctx._pattern = this.stringLiteral(); + this.state = 1230; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.BITWISEOR) { + { + { + this.state = 1226; + this.match(ImpalaSqlParser.BITWISEOR); + this.state = 1227; + this.stringLiteral(); + } + } + this.state = 1232; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showCreateTable(): ShowCreateTableContext { + let _localctx: ShowCreateTableContext = new ShowCreateTableContext(this._ctx, this.state); + this.enterRule(_localctx, 118, ImpalaSqlParser.RULE_showCreateTable); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1235; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1236; + this.match(ImpalaSqlParser.KW_CREATE); + this.state = 1237; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 1238; + this.tableNamePath(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showCreateView(): ShowCreateViewContext { + let _localctx: ShowCreateViewContext = new ShowCreateViewContext(this._ctx, this.state); + this.enterRule(_localctx, 120, ImpalaSqlParser.RULE_showCreateView); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1240; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1241; + this.match(ImpalaSqlParser.KW_CREATE); + this.state = 1242; + this.match(ImpalaSqlParser.KW_VIEW); + this.state = 1243; + this.viewNamePath(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showTableStats(): ShowTableStatsContext { + let _localctx: ShowTableStatsContext = new ShowTableStatsContext(this._ctx, this.state); + this.enterRule(_localctx, 122, ImpalaSqlParser.RULE_showTableStats); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1245; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1246; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 1247; + this.match(ImpalaSqlParser.KW_STATS); + this.state = 1248; + this.tableNamePath(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showColumnStats(): ShowColumnStatsContext { + let _localctx: ShowColumnStatsContext = new ShowColumnStatsContext(this._ctx, this.state); + this.enterRule(_localctx, 124, ImpalaSqlParser.RULE_showColumnStats); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1250; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1251; + this.match(ImpalaSqlParser.KW_COLUMN); + this.state = 1252; + this.match(ImpalaSqlParser.KW_STATS); + this.state = 1253; + this.tableNamePath(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showPartitions(): ShowPartitionsContext { + let _localctx: ShowPartitionsContext = new ShowPartitionsContext(this._ctx, this.state); + this.enterRule(_localctx, 126, ImpalaSqlParser.RULE_showPartitions); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1255; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1257; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_RANGE) { + { + this.state = 1256; + this.match(ImpalaSqlParser.KW_RANGE); + } + } + + this.state = 1259; + this.match(ImpalaSqlParser.KW_PARTITIONS); + this.state = 1260; + this.tableNamePath(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showFiles(): ShowFilesContext { + let _localctx: ShowFilesContext = new ShowFilesContext(this._ctx, this.state); + this.enterRule(_localctx, 128, ImpalaSqlParser.RULE_showFiles); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1262; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1263; + this.match(ImpalaSqlParser.KW_FILES); + this.state = 1264; + this.match(ImpalaSqlParser.KW_IN); + this.state = 1265; + this.tableNamePath(); + this.state = 1275; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PARTITION) { + { + this.state = 1266; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 1267; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1268; + this.expression(); + this.state = 1271; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.COMMA) { + { + this.state = 1269; + this.match(ImpalaSqlParser.COMMA); + this.state = 1270; + this.expression(); + } + } + + this.state = 1273; + this.match(ImpalaSqlParser.RPAREN); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showRoles(): ShowRolesContext { + let _localctx: ShowRolesContext = new ShowRolesContext(this._ctx, this.state); + this.enterRule(_localctx, 130, ImpalaSqlParser.RULE_showRoles); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1277; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1279; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_CURRENT) { + { + this.state = 1278; + this.match(ImpalaSqlParser.KW_CURRENT); + } + } + + this.state = 1281; + this.match(ImpalaSqlParser.KW_ROLES); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showRoleGrant(): ShowRoleGrantContext { + let _localctx: ShowRoleGrantContext = new ShowRoleGrantContext(this._ctx, this.state); + this.enterRule(_localctx, 132, ImpalaSqlParser.RULE_showRoleGrant); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1283; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1284; + this.match(ImpalaSqlParser.KW_ROLE); + this.state = 1285; + this.match(ImpalaSqlParser.KW_GRANT); + this.state = 1286; + this.match(ImpalaSqlParser.KW_GROUP); + this.state = 1287; + this.identifier(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showGrants(): ShowGrantsContext { + let _localctx: ShowGrantsContext = new ShowGrantsContext(this._ctx, this.state); + this.enterRule(_localctx, 134, ImpalaSqlParser.RULE_showGrants); + let _la: number; + try { + this.state = 1303; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 139, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 1289; + this.showDatabaseGrant(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1290; + this.showTableGrant(); + } + break; + + case 3: + this.enterOuterAlt(_localctx, 3); + { + this.state = 1291; + this.showColumnGrant(); + } + break; + + case 4: + this.enterOuterAlt(_localctx, 4); + { + this.state = 1292; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1293; + this.match(ImpalaSqlParser.KW_GRANT); + this.state = 1294; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_GROUP || _la === ImpalaSqlParser.KW_ROLE || _la === ImpalaSqlParser.KW_USER)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1295; + this.identifier(); + this.state = 1301; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ON) { + { + this.state = 1296; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1297; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_SERVER || _la === ImpalaSqlParser.KW_URI)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1299; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 137, this._ctx) ) { + case 1: + { + this.state = 1298; + this.qualifiedName(); + } + break; + } + } + } + + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showDatabaseGrant(): ShowDatabaseGrantContext { + let _localctx: ShowDatabaseGrantContext = new ShowDatabaseGrantContext(this._ctx, this.state); + this.enterRule(_localctx, 136, ImpalaSqlParser.RULE_showDatabaseGrant); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1305; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1306; + this.match(ImpalaSqlParser.KW_GRANT); + this.state = 1307; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_GROUP || _la === ImpalaSqlParser.KW_ROLE || _la === ImpalaSqlParser.KW_USER)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1308; + this.identifier(); + this.state = 1314; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ON) { + { + this.state = 1309; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1310; + this.match(ImpalaSqlParser.KW_DATABASE); + this.state = 1312; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 140, this._ctx) ) { + case 1: + { + this.state = 1311; + this.databaseNamePath(); + } + break; + } + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showTableGrant(): ShowTableGrantContext { + let _localctx: ShowTableGrantContext = new ShowTableGrantContext(this._ctx, this.state); + this.enterRule(_localctx, 138, ImpalaSqlParser.RULE_showTableGrant); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1316; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1317; + this.match(ImpalaSqlParser.KW_GRANT); + this.state = 1318; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_GROUP || _la === ImpalaSqlParser.KW_ROLE || _la === ImpalaSqlParser.KW_USER)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1319; + this.identifier(); + this.state = 1325; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ON) { + { + this.state = 1320; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1321; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 1323; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 142, this._ctx) ) { + case 1: + { + this.state = 1322; + this.tableNamePath(); + } + break; + } + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public showColumnGrant(): ShowColumnGrantContext { + let _localctx: ShowColumnGrantContext = new ShowColumnGrantContext(this._ctx, this.state); + this.enterRule(_localctx, 140, ImpalaSqlParser.RULE_showColumnGrant); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1327; + this.match(ImpalaSqlParser.KW_SHOW); + this.state = 1328; + this.match(ImpalaSqlParser.KW_GRANT); + this.state = 1329; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_GROUP || _la === ImpalaSqlParser.KW_ROLE || _la === ImpalaSqlParser.KW_USER)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1330; + this.identifier(); + this.state = 1336; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ON) { + { + this.state = 1331; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1332; + this.match(ImpalaSqlParser.KW_COLUMN); + this.state = 1334; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 144, this._ctx) ) { + case 1: + { + this.state = 1333; + this.columnNamePath(); + } + break; + } + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public addCommentStatement(): AddCommentStatementContext { + let _localctx: AddCommentStatementContext = new AddCommentStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 142, ImpalaSqlParser.RULE_addCommentStatement); + try { + this.state = 1341; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 146, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 1338; + this.addDatabaseComments(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1339; + this.addTableComments(); + } + break; + + case 3: + this.enterOuterAlt(_localctx, 3); + { + this.state = 1340; + this.addColumnComments(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public addDatabaseComments(): AddDatabaseCommentsContext { + let _localctx: AddDatabaseCommentsContext = new AddDatabaseCommentsContext(this._ctx, this.state); + this.enterRule(_localctx, 144, ImpalaSqlParser.RULE_addDatabaseComments); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1343; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 1344; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1345; + this.match(ImpalaSqlParser.KW_DATABASE); + this.state = 1346; + this.databaseNamePath(); + this.state = 1347; + this.match(ImpalaSqlParser.KW_IS); + this.state = 1350; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.STRING: + case ImpalaSqlParser.UNICODE_STRING: + { + this.state = 1348; + this.stringLiteral(); + } + break; + case ImpalaSqlParser.KW_NULL: + { + this.state = 1349; + this.match(ImpalaSqlParser.KW_NULL); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public addTableComments(): AddTableCommentsContext { + let _localctx: AddTableCommentsContext = new AddTableCommentsContext(this._ctx, this.state); + this.enterRule(_localctx, 146, ImpalaSqlParser.RULE_addTableComments); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1352; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 1353; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1354; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 1355; + this.tableNamePath(); + this.state = 1356; + this.match(ImpalaSqlParser.KW_IS); + this.state = 1359; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.STRING: + case ImpalaSqlParser.UNICODE_STRING: + { + this.state = 1357; + this.stringLiteral(); + } + break; + case ImpalaSqlParser.KW_NULL: + { + this.state = 1358; + this.match(ImpalaSqlParser.KW_NULL); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public addColumnComments(): AddColumnCommentsContext { + let _localctx: AddColumnCommentsContext = new AddColumnCommentsContext(this._ctx, this.state); + this.enterRule(_localctx, 148, ImpalaSqlParser.RULE_addColumnComments); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1361; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 1362; + this.match(ImpalaSqlParser.KW_ON); + this.state = 1363; + this.match(ImpalaSqlParser.KW_COLUMN); + this.state = 1364; + this.columnNamePath(); + this.state = 1365; + this.match(ImpalaSqlParser.KW_IS); + this.state = 1368; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.STRING: + case ImpalaSqlParser.UNICODE_STRING: + { + this.state = 1366; + this.stringLiteral(); + } + break; + case ImpalaSqlParser.KW_NULL: + { + this.state = 1367; + this.match(ImpalaSqlParser.KW_NULL); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public explainStatement(): ExplainStatementContext { + let _localctx: ExplainStatementContext = new ExplainStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 150, ImpalaSqlParser.RULE_explainStatement); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1370; + this.match(ImpalaSqlParser.KW_EXPLAIN); + this.state = 1371; + this.statement(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public setStatement(): SetStatementContext { + let _localctx: SetStatementContext = new SetStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 152, ImpalaSqlParser.RULE_setStatement); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1373; + this.match(ImpalaSqlParser.KW_SET); + this.state = 1379; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 150, this._ctx) ) { + case 1: + { + this.state = 1374; + this.match(ImpalaSqlParser.KW_ALL); + } + break; + + case 2: + { + this.state = 1375; + this.identifier(); + this.state = 1376; + this.match(ImpalaSqlParser.EQ); + this.state = 1377; + this.expression(); + } + break; + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public shutdownStatement(): ShutdownStatementContext { + let _localctx: ShutdownStatementContext = new ShutdownStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 154, ImpalaSqlParser.RULE_shutdownStatement); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1381; + this.match(ImpalaSqlParser.COLON); + this.state = 1382; + this.match(ImpalaSqlParser.KW_SHUTDOWN); + this.state = 1383; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1393; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 153, this._ctx) ) { + case 1: + { + this.state = 1385; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.STRING || _la === ImpalaSqlParser.UNICODE_STRING) { + { + this.state = 1384; + this.stringLiteral(); + } + } + + } + break; + + case 2: + { + this.state = 1387; + this.stringLiteral(); + this.state = 1390; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.COMMA) { + { + this.state = 1388; + this.match(ImpalaSqlParser.COMMA); + this.state = 1389; + this.expression(); + } + } + + } + break; + + case 3: + { + this.state = 1392; + this.expression(); + } + break; + } + this.state = 1395; + this.match(ImpalaSqlParser.RPAREN); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public invalidateMetaStatement(): InvalidateMetaStatementContext { + let _localctx: InvalidateMetaStatementContext = new InvalidateMetaStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 156, ImpalaSqlParser.RULE_invalidateMetaStatement); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1397; + this.match(ImpalaSqlParser.KW_INVALIDATE); + this.state = 1398; + this.match(ImpalaSqlParser.KW_METADATA); + this.state = 1399; + this.tableNamePath(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public loadDataStatement(): LoadDataStatementContext { + let _localctx: LoadDataStatementContext = new LoadDataStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 158, ImpalaSqlParser.RULE_loadDataStatement); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1401; + this.match(ImpalaSqlParser.KW_LOAD); + this.state = 1402; + this.match(ImpalaSqlParser.KW_DATA); + this.state = 1403; + this.match(ImpalaSqlParser.KW_INPATH); + this.state = 1404; + this.match(ImpalaSqlParser.STRING); + this.state = 1406; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_OVERWRITE) { + { + this.state = 1405; + this.match(ImpalaSqlParser.KW_OVERWRITE); + } + } + + this.state = 1408; + this.match(ImpalaSqlParser.KW_INTO); + this.state = 1409; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 1410; + this.tableNamePath(); + this.state = 1420; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PARTITION) { + { + this.state = 1411; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 1412; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1413; + this.expression(); + this.state = 1416; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.COMMA) { + { + this.state = 1414; + this.match(ImpalaSqlParser.COMMA); + this.state = 1415; + this.expression(); + } + } + + this.state = 1418; + this.match(ImpalaSqlParser.RPAREN); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public refreshStatement(): RefreshStatementContext { + let _localctx: RefreshStatementContext = new RefreshStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 160, ImpalaSqlParser.RULE_refreshStatement); + try { + this.state = 1425; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 157, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 1422; + this.refreshMeta(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1423; + this.refreshAuth(); + } + break; + + case 3: + this.enterOuterAlt(_localctx, 3); + { + this.state = 1424; + this.refreshFunction(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public refreshMeta(): RefreshMetaContext { + let _localctx: RefreshMetaContext = new RefreshMetaContext(this._ctx, this.state); + this.enterRule(_localctx, 162, ImpalaSqlParser.RULE_refreshMeta); + let _la: number; + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 1427; + this.match(ImpalaSqlParser.KW_REFRESH); + this.state = 1428; + this.tableNamePath(); + this.state = 1441; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PARTITION) { + { + this.state = 1429; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 1430; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1431; + this.expression(); + this.state = 1436; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 158, this._ctx); + while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1 + 1) { + { + { + this.state = 1432; + this.match(ImpalaSqlParser.COMMA); + this.state = 1433; + this.expression(); + } + } + } + this.state = 1438; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 158, this._ctx); + } + this.state = 1439; + this.match(ImpalaSqlParser.RPAREN); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public refreshAuth(): RefreshAuthContext { + let _localctx: RefreshAuthContext = new RefreshAuthContext(this._ctx, this.state); + this.enterRule(_localctx, 164, ImpalaSqlParser.RULE_refreshAuth); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1443; + this.match(ImpalaSqlParser.KW_REFRESH); + this.state = 1444; + this.match(ImpalaSqlParser.KW_AUTHORIZATION); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public refreshFunction(): RefreshFunctionContext { + let _localctx: RefreshFunctionContext = new RefreshFunctionContext(this._ctx, this.state); + this.enterRule(_localctx, 166, ImpalaSqlParser.RULE_refreshFunction); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1446; + this.match(ImpalaSqlParser.KW_REFRESH); + this.state = 1447; + this.match(ImpalaSqlParser.KW_FUNCTIONS); + this.state = 1448; + this.functionNamePath(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public ifExists(): IfExistsContext { + let _localctx: IfExistsContext = new IfExistsContext(this._ctx, this.state); + this.enterRule(_localctx, 168, ImpalaSqlParser.RULE_ifExists); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1450; + this.match(ImpalaSqlParser.KW_IF); + this.state = 1451; + this.match(ImpalaSqlParser.KW_EXISTS); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public ifNotExists(): IfNotExistsContext { + let _localctx: IfNotExistsContext = new IfNotExistsContext(this._ctx, this.state); + this.enterRule(_localctx, 170, ImpalaSqlParser.RULE_ifNotExists); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1453; + this.match(ImpalaSqlParser.KW_IF); + this.state = 1454; + this.match(ImpalaSqlParser.KW_NOT); + this.state = 1455; + this.match(ImpalaSqlParser.KW_EXISTS); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public tableNameCreate(): TableNameCreateContext { + let _localctx: TableNameCreateContext = new TableNameCreateContext(this._ctx, this.state); + this.enterRule(_localctx, 172, ImpalaSqlParser.RULE_tableNameCreate); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1457; + this.qualifiedName(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public databaseNameCreate(): DatabaseNameCreateContext { + let _localctx: DatabaseNameCreateContext = new DatabaseNameCreateContext(this._ctx, this.state); + this.enterRule(_localctx, 174, ImpalaSqlParser.RULE_databaseNameCreate); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1459; + this.qualifiedName(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public viewNameCreate(): ViewNameCreateContext { + let _localctx: ViewNameCreateContext = new ViewNameCreateContext(this._ctx, this.state); + this.enterRule(_localctx, 176, ImpalaSqlParser.RULE_viewNameCreate); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1461; + this.qualifiedName(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public functionNameCreate(): FunctionNameCreateContext { + let _localctx: FunctionNameCreateContext = new FunctionNameCreateContext(this._ctx, this.state); + this.enterRule(_localctx, 178, ImpalaSqlParser.RULE_functionNameCreate); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1463; + this.qualifiedName(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public columnNamePathCreate(): ColumnNamePathCreateContext { + let _localctx: ColumnNamePathCreateContext = new ColumnNamePathCreateContext(this._ctx, this.state); + this.enterRule(_localctx, 180, ImpalaSqlParser.RULE_columnNamePathCreate); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1465; + this.qualifiedName(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public databaseNamePath(): DatabaseNamePathContext { + let _localctx: DatabaseNamePathContext = new DatabaseNamePathContext(this._ctx, this.state); + this.enterRule(_localctx, 182, ImpalaSqlParser.RULE_databaseNamePath); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1467; + this.qualifiedName(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public tableNamePath(): TableNamePathContext { + let _localctx: TableNamePathContext = new TableNamePathContext(this._ctx, this.state); + this.enterRule(_localctx, 184, ImpalaSqlParser.RULE_tableNamePath); + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 1469; + this.identifier(); + this.state = 1474; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 160, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + { + { + this.state = 1470; + this.match(ImpalaSqlParser.DOT); + this.state = 1471; + this.identifier(); + } + } + } + this.state = 1476; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 160, this._ctx); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public viewNamePath(): ViewNamePathContext { + let _localctx: ViewNamePathContext = new ViewNamePathContext(this._ctx, this.state); + this.enterRule(_localctx, 186, ImpalaSqlParser.RULE_viewNamePath); + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 1477; + this.identifier(); + this.state = 1482; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 161, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + { + { + this.state = 1478; + this.match(ImpalaSqlParser.DOT); + this.state = 1479; + this.identifier(); + } + } + } + this.state = 1484; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 161, this._ctx); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public functionNamePath(): FunctionNamePathContext { + let _localctx: FunctionNamePathContext = new FunctionNamePathContext(this._ctx, this.state); + this.enterRule(_localctx, 188, ImpalaSqlParser.RULE_functionNamePath); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1485; + this.qualifiedName(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public columnNamePath(): ColumnNamePathContext { + let _localctx: ColumnNamePathContext = new ColumnNamePathContext(this._ctx, this.state); + this.enterRule(_localctx, 190, ImpalaSqlParser.RULE_columnNamePath); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1487; + this.qualifiedName(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public tableOrViewPath(): TableOrViewPathContext { + let _localctx: TableOrViewPathContext = new TableOrViewPathContext(this._ctx, this.state); + this.enterRule(_localctx, 192, ImpalaSqlParser.RULE_tableOrViewPath); + try { + this.state = 1491; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 162, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 1489; + this.tableNamePath(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1490; + this.viewNamePath(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public createCommonItem(): CreateCommonItemContext { + let _localctx: CreateCommonItemContext = new CreateCommonItemContext(this._ctx, this.state); + this.enterRule(_localctx, 194, ImpalaSqlParser.RULE_createCommonItem); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1496; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_SORT) { + { + this.state = 1493; + this.match(ImpalaSqlParser.KW_SORT); + this.state = 1494; + this.match(ImpalaSqlParser.KW_BY); + this.state = 1495; + this.columnAliases(); + } + } + + this.state = 1500; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 164, this._ctx) ) { + case 1: + { + this.state = 1498; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 1499; + _localctx._comment = this.stringLiteral(); + } + break; + } + this.state = 1505; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ROW) { + { + this.state = 1502; + this.match(ImpalaSqlParser.KW_ROW); + this.state = 1503; + this.match(ImpalaSqlParser.KW_FORMAT); + this.state = 1504; + this.rowFormat(); + } + } + + this.state = 1510; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 166, this._ctx) ) { + case 1: + { + this.state = 1507; + this.match(ImpalaSqlParser.KW_WITH); + this.state = 1508; + this.match(ImpalaSqlParser.KW_SERDEPROPERTIES); + this.state = 1509; + _localctx._serdProp = this.properties(); + } + break; + } + this.state = 1515; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_STORED) { + { + this.state = 1512; + this.match(ImpalaSqlParser.KW_STORED); + this.state = 1513; + this.match(ImpalaSqlParser.KW_AS); + this.state = 1514; + this.fileFormat(); + } + } + + this.state = 1519; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_LOCATION) { + { + this.state = 1517; + this.match(ImpalaSqlParser.KW_LOCATION); + this.state = 1518; + _localctx._location = this.stringLiteral(); + } + } + + this.state = 1531; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_CACHED: + { + this.state = 1521; + this.match(ImpalaSqlParser.KW_CACHED); + this.state = 1522; + this.match(ImpalaSqlParser.KW_IN); + this.state = 1523; + _localctx._cacheName = this.qualifiedName(); + this.state = 1528; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 169, this._ctx) ) { + case 1: + { + this.state = 1524; + this.match(ImpalaSqlParser.KW_WITH); + this.state = 1525; + this.match(ImpalaSqlParser.KW_REPLICATION); + this.state = 1526; + this.match(ImpalaSqlParser.EQ); + this.state = 1527; + this.match(ImpalaSqlParser.INTEGER_VALUE); + } + break; + } + } + break; + case ImpalaSqlParser.KW_UNCACHED: + { + this.state = 1530; + this.match(ImpalaSqlParser.KW_UNCACHED); + } + break; + case ImpalaSqlParser.EOF: + case ImpalaSqlParser.KW_ALTER: + case ImpalaSqlParser.KW_AS: + case ImpalaSqlParser.KW_TBLPROPERTIES: + case ImpalaSqlParser.KW_COMMENT: + case ImpalaSqlParser.KW_COMPUTE: + case ImpalaSqlParser.KW_CREATE: + case ImpalaSqlParser.KW_DELETE: + case ImpalaSqlParser.KW_UPDATE: + case ImpalaSqlParser.KW_DESCRIBE: + case ImpalaSqlParser.KW_DROP: + case ImpalaSqlParser.KW_EXPLAIN: + case ImpalaSqlParser.KW_GRANT: + case ImpalaSqlParser.KW_INSERT: + case ImpalaSqlParser.KW_INVALIDATE: + case ImpalaSqlParser.KW_LOAD: + case ImpalaSqlParser.KW_REVOKE: + case ImpalaSqlParser.KW_REFRESH: + case ImpalaSqlParser.KW_SELECT: + case ImpalaSqlParser.KW_SET: + case ImpalaSqlParser.KW_SHOW: + case ImpalaSqlParser.KW_TABLE: + case ImpalaSqlParser.KW_TRUNCATE: + case ImpalaSqlParser.KW_USE: + case ImpalaSqlParser.KW_UPSERT: + case ImpalaSqlParser.KW_VALUES: + case ImpalaSqlParser.KW_WITH: + case ImpalaSqlParser.SEMICOLON: + case ImpalaSqlParser.COLON: + case ImpalaSqlParser.LPAREN: + break; + default: + break; + } + this.state = 1535; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_TBLPROPERTIES) { + { + this.state = 1533; + this.match(ImpalaSqlParser.KW_TBLPROPERTIES); + this.state = 1534; + _localctx._tblProp = this.properties(); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public assignmentList(): AssignmentListContext { + let _localctx: AssignmentListContext = new AssignmentListContext(this._ctx, this.state); + this.enterRule(_localctx, 196, ImpalaSqlParser.RULE_assignmentList); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1537; + this.assignmentItem(); + this.state = 1542; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 1538; + this.match(ImpalaSqlParser.COMMA); + this.state = 1539; + this.assignmentItem(); + } + } + this.state = 1544; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public assignmentItem(): AssignmentItemContext { + let _localctx: AssignmentItemContext = new AssignmentItemContext(this._ctx, this.state); + this.enterRule(_localctx, 198, ImpalaSqlParser.RULE_assignmentItem); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1545; + this.qualifiedName(); + this.state = 1546; + this.match(ImpalaSqlParser.EQ); + this.state = 1547; + this.expression(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public viewColumns(): ViewColumnsContext { + let _localctx: ViewColumnsContext = new ViewColumnsContext(this._ctx, this.state); + this.enterRule(_localctx, 200, ImpalaSqlParser.RULE_viewColumns); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1549; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1550; + this.columnNamePath(); + this.state = 1553; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_COMMENT) { + { + this.state = 1551; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 1552; + this.stringLiteral(); + } + } + + this.state = 1563; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 1555; + this.match(ImpalaSqlParser.COMMA); + this.state = 1556; + this.identifier(); + this.state = 1559; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_COMMENT) { + { + this.state = 1557; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 1558; + this.stringLiteral(); + } + } + + } + } + this.state = 1565; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 1566; + this.match(ImpalaSqlParser.RPAREN); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public queryStatement(): QueryStatementContext { + let _localctx: QueryStatementContext = new QueryStatementContext(this._ctx, this.state); + this.enterRule(_localctx, 202, ImpalaSqlParser.RULE_queryStatement); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1569; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_WITH) { + { + this.state = 1568; + this.with(); + } + } + + this.state = 1571; + this.queryNoWith(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public with(): WithContext { + let _localctx: WithContext = new WithContext(this._ctx, this.state); + this.enterRule(_localctx, 204, ImpalaSqlParser.RULE_with); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1573; + this.match(ImpalaSqlParser.KW_WITH); + this.state = 1574; + this.namedQuery(); + this.state = 1579; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 1575; + this.match(ImpalaSqlParser.COMMA); + this.state = 1576; + this.namedQuery(); + } + } + this.state = 1581; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public constraintSpecification(): ConstraintSpecificationContext { + let _localctx: ConstraintSpecificationContext = new ConstraintSpecificationContext(this._ctx, this.state); + this.enterRule(_localctx, 206, ImpalaSqlParser.RULE_constraintSpecification); + let _la: number; + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 1582; + this.match(ImpalaSqlParser.KW_PRIMARY); + this.state = 1583; + this.match(ImpalaSqlParser.KW_KEY); + this.state = 1584; + this.columnAliases(); + this.state = 1586; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_DISABLE) { + { + this.state = 1585; + this.match(ImpalaSqlParser.KW_DISABLE); + } + } + + this.state = 1591; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 179, this._ctx) ) { + case 1: + { + this.state = 1588; + this.match(ImpalaSqlParser.KW_NOVALIDATE); + } + break; + + case 2: + { + this.state = 1589; + this.match(ImpalaSqlParser.COMMA); + this.state = 1590; + this.match(ImpalaSqlParser.KW_NOVALIDATE); + } + break; + } + this.state = 1596; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 180, this._ctx) ) { + case 1: + { + this.state = 1593; + this.match(ImpalaSqlParser.KW_RELY); + } + break; + + case 2: + { + this.state = 1594; + this.match(ImpalaSqlParser.COMMA); + this.state = 1595; + this.match(ImpalaSqlParser.KW_RELY); + } + break; + } + this.state = 1610; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_FOREIGN || _la === ImpalaSqlParser.COMMA) { + { + this.state = 1601; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.COMMA: + { + this.state = 1598; + this.match(ImpalaSqlParser.COMMA); + this.state = 1599; + this.foreignKeySpecification(); + } + break; + case ImpalaSqlParser.KW_FOREIGN: + { + this.state = 1600; + this.foreignKeySpecification(); + } + break; + default: + throw new NoViableAltException(this); + } + this.state = 1607; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 182, this._ctx); + while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1 + 1) { + { + { + this.state = 1603; + this.match(ImpalaSqlParser.COMMA); + this.state = 1604; + this.foreignKeySpecification(); + } + } + } + this.state = 1609; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 182, this._ctx); + } + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public foreignKeySpecification(): ForeignKeySpecificationContext { + let _localctx: ForeignKeySpecificationContext = new ForeignKeySpecificationContext(this._ctx, this.state); + this.enterRule(_localctx, 208, ImpalaSqlParser.RULE_foreignKeySpecification); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1612; + this.match(ImpalaSqlParser.KW_FOREIGN); + this.state = 1613; + this.match(ImpalaSqlParser.KW_KEY); + this.state = 1614; + this.columnAliases(); + this.state = 1615; + this.match(ImpalaSqlParser.KW_REFERENCES); + this.state = 1616; + this.tableNamePath(); + this.state = 1617; + this.columnAliases(); + this.state = 1619; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_DISABLE) { + { + this.state = 1618; + this.match(ImpalaSqlParser.KW_DISABLE); + } + } + + this.state = 1622; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_NOVALIDATE) { + { + this.state = 1621; + this.match(ImpalaSqlParser.KW_NOVALIDATE); + } + } + + this.state = 1625; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_RELY) { + { + this.state = 1624; + this.match(ImpalaSqlParser.KW_RELY); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public columnDefinition(): ColumnDefinitionContext { + let _localctx: ColumnDefinitionContext = new ColumnDefinitionContext(this._ctx, this.state); + this.enterRule(_localctx, 210, ImpalaSqlParser.RULE_columnDefinition); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1627; + this.columnNamePathCreate(); + this.state = 1628; + this.type(0); + this.state = 1631; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_COMMENT) { + { + this.state = 1629; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 1630; + this.stringLiteral(); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public kuduTableElement(): KuduTableElementContext { + let _localctx: KuduTableElementContext = new KuduTableElementContext(this._ctx, this.state); + this.enterRule(_localctx, 212, ImpalaSqlParser.RULE_kuduTableElement); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1633; + this.kuduColumnDefinition(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public kuduColumnDefinition(): KuduColumnDefinitionContext { + let _localctx: KuduColumnDefinitionContext = new KuduColumnDefinitionContext(this._ctx, this.state); + this.enterRule(_localctx, 214, ImpalaSqlParser.RULE_kuduColumnDefinition); + let _la: number; + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 1635; + this.columnNamePathCreate(); + this.state = 1636; + this.type(0); + this.state = 1644; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_BLOCK_SIZE || ((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & ((1 << (ImpalaSqlParser.KW_COMPRESSION - 35)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 35)) | (1 << (ImpalaSqlParser.KW_ENCODING - 35)))) !== 0) || _la === ImpalaSqlParser.KW_NOT || _la === ImpalaSqlParser.KW_NULL) { + { + this.state = 1637; + this.kuduAttributes(); + this.state = 1641; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 188, this._ctx); + while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1 + 1) { + { + { + this.state = 1638; + this.kuduAttributes(); + } + } + } + this.state = 1643; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 188, this._ctx); + } + } + } + + this.state = 1648; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_COMMENT) { + { + this.state = 1646; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 1647; + this.stringLiteral(); + } + } + + this.state = 1652; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PRIMARY) { + { + this.state = 1650; + this.match(ImpalaSqlParser.KW_PRIMARY); + this.state = 1651; + this.match(ImpalaSqlParser.KW_KEY); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public columnSpecWithKudu(): ColumnSpecWithKuduContext { + let _localctx: ColumnSpecWithKuduContext = new ColumnSpecWithKuduContext(this._ctx, this.state); + this.enterRule(_localctx, 216, ImpalaSqlParser.RULE_columnSpecWithKudu); + let _la: number; + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 1654; + this.columnNamePath(); + this.state = 1655; + this.type(0); + this.state = 1658; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 192, this._ctx) ) { + case 1: + { + this.state = 1656; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 1657; + this.stringLiteral(); + } + break; + } + this.state = 1667; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_BLOCK_SIZE || ((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & ((1 << (ImpalaSqlParser.KW_COMPRESSION - 35)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 35)) | (1 << (ImpalaSqlParser.KW_ENCODING - 35)))) !== 0) || _la === ImpalaSqlParser.KW_NOT || _la === ImpalaSqlParser.KW_NULL) { + { + this.state = 1660; + this.kuduAttributes(); + this.state = 1664; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 193, this._ctx); + while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1 + 1) { + { + { + this.state = 1661; + this.kuduAttributes(); + } + } + } + this.state = 1666; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 193, this._ctx); + } + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public createColumnSpecWithKudu(): CreateColumnSpecWithKuduContext { + let _localctx: CreateColumnSpecWithKuduContext = new CreateColumnSpecWithKuduContext(this._ctx, this.state); + this.enterRule(_localctx, 218, ImpalaSqlParser.RULE_createColumnSpecWithKudu); + let _la: number; + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 1669; + this.columnNamePathCreate(); + this.state = 1670; + this.type(0); + this.state = 1673; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 195, this._ctx) ) { + case 1: + { + this.state = 1671; + this.match(ImpalaSqlParser.KW_COMMENT); + this.state = 1672; + this.stringLiteral(); + } + break; + } + this.state = 1682; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_BLOCK_SIZE || ((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & ((1 << (ImpalaSqlParser.KW_COMPRESSION - 35)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 35)) | (1 << (ImpalaSqlParser.KW_ENCODING - 35)))) !== 0) || _la === ImpalaSqlParser.KW_NOT || _la === ImpalaSqlParser.KW_NULL) { + { + this.state = 1675; + this.kuduAttributes(); + this.state = 1679; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 196, this._ctx); + while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1 + 1) { + { + { + this.state = 1676; + this.kuduAttributes(); + } + } + } + this.state = 1681; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 196, this._ctx); + } + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public kuduAttributes(): KuduAttributesContext { + let _localctx: KuduAttributesContext = new KuduAttributesContext(this._ctx, this.state); + this.enterRule(_localctx, 220, ImpalaSqlParser.RULE_kuduAttributes); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1689; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_NOT: + case ImpalaSqlParser.KW_NULL: + { + this.state = 1685; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_NOT) { + { + this.state = 1684; + this.match(ImpalaSqlParser.KW_NOT); + } + } + + this.state = 1687; + this.match(ImpalaSqlParser.KW_NULL); + } + break; + case ImpalaSqlParser.KW_BLOCK_SIZE: + case ImpalaSqlParser.KW_COMPRESSION: + case ImpalaSqlParser.KW_DEFAULT: + case ImpalaSqlParser.KW_ENCODING: + { + this.state = 1688; + this.kuduStorageAttr(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public kuduStorageAttr(): KuduStorageAttrContext { + let _localctx: KuduStorageAttrContext = new KuduStorageAttrContext(this._ctx, this.state); + this.enterRule(_localctx, 222, ImpalaSqlParser.RULE_kuduStorageAttr); + try { + this.state = 1699; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_ENCODING: + this.enterOuterAlt(_localctx, 1); + { + this.state = 1691; + this.match(ImpalaSqlParser.KW_ENCODING); + this.state = 1692; + this.expression(); + } + break; + case ImpalaSqlParser.KW_COMPRESSION: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1693; + this.match(ImpalaSqlParser.KW_COMPRESSION); + this.state = 1694; + this.expression(); + } + break; + case ImpalaSqlParser.KW_DEFAULT: + this.enterOuterAlt(_localctx, 3); + { + this.state = 1695; + this.match(ImpalaSqlParser.KW_DEFAULT); + this.state = 1696; + this.expression(); + } + break; + case ImpalaSqlParser.KW_BLOCK_SIZE: + this.enterOuterAlt(_localctx, 4); + { + this.state = 1697; + this.match(ImpalaSqlParser.KW_BLOCK_SIZE); + this.state = 1698; + this.number(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public statsKey(): StatsKeyContext { + let _localctx: StatsKeyContext = new StatsKeyContext(this._ctx, this.state); + this.enterRule(_localctx, 224, ImpalaSqlParser.RULE_statsKey); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1701; + _la = this._input.LA(1); + if (!(((((_la - 226)) & ~0x1F) === 0 && ((1 << (_la - 226)) & ((1 << (ImpalaSqlParser.STATS_NUMDVS - 226)) | (1 << (ImpalaSqlParser.STATS_NUMNULLS - 226)) | (1 << (ImpalaSqlParser.STATS_AVGSIZE - 226)) | (1 << (ImpalaSqlParser.STATS_MAXSIZE - 226)))) !== 0))) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public fileFormat(): FileFormatContext { + let _localctx: FileFormatContext = new FileFormatContext(this._ctx, this.state); + this.enterRule(_localctx, 226, ImpalaSqlParser.RULE_fileFormat); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1703; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_PARQUET || ((((_la - 218)) & ~0x1F) === 0 && ((1 << (_la - 218)) & ((1 << (ImpalaSqlParser.KW_TEXTFILE - 218)) | (1 << (ImpalaSqlParser.KW_ORC - 218)) | (1 << (ImpalaSqlParser.KW_AVRO - 218)) | (1 << (ImpalaSqlParser.KW_SEQUENCEFILE - 218)) | (1 << (ImpalaSqlParser.KW_RCFILE - 218)))) !== 0))) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public kuduPartitionClause(): KuduPartitionClauseContext { + let _localctx: KuduPartitionClauseContext = new KuduPartitionClauseContext(this._ctx, this.state); + this.enterRule(_localctx, 228, ImpalaSqlParser.RULE_kuduPartitionClause); + let _la: number; + try { + let _alt: number; + this.state = 1718; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_HASH: + this.enterOuterAlt(_localctx, 1); + { + { + this.state = 1705; + this.hashClause(); + this.state = 1710; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 201, this._ctx); + while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1 + 1) { + { + { + this.state = 1706; + this.match(ImpalaSqlParser.COMMA); + this.state = 1707; + this.hashClause(); + } + } + } + this.state = 1712; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 201, this._ctx); + } + this.state = 1715; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.COMMA) { + { + this.state = 1713; + this.match(ImpalaSqlParser.COMMA); + this.state = 1714; + this.rangeClause(); + } + } + + } + } + break; + case ImpalaSqlParser.KW_RANGE: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1717; + this.rangeClause(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public hashClause(): HashClauseContext { + let _localctx: HashClauseContext = new HashClauseContext(this._ctx, this.state); + this.enterRule(_localctx, 230, ImpalaSqlParser.RULE_hashClause); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1720; + this.match(ImpalaSqlParser.KW_HASH); + this.state = 1722; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.LPAREN) { + { + this.state = 1721; + this.columnAliases(); + } + } + + this.state = 1724; + this.match(ImpalaSqlParser.KW_PARTITIONS); + this.state = 1725; + this.number(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public rangeClause(): RangeClauseContext { + let _localctx: RangeClauseContext = new RangeClauseContext(this._ctx, this.state); + this.enterRule(_localctx, 232, ImpalaSqlParser.RULE_rangeClause); + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 1727; + this.match(ImpalaSqlParser.KW_RANGE); + this.state = 1729; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 205, this._ctx) ) { + case 1: + { + this.state = 1728; + this.columnAliases(); + } + break; + } + this.state = 1731; + this.match(ImpalaSqlParser.LPAREN); + { + this.state = 1732; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 1733; + this.kuduPartitionSpec(); + this.state = 1739; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 206, this._ctx); + while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1 + 1) { + { + { + this.state = 1734; + this.match(ImpalaSqlParser.COMMA); + this.state = 1735; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 1736; + this.kuduPartitionSpec(); + } + } + } + this.state = 1741; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 206, this._ctx); + } + } + this.state = 1742; + this.match(ImpalaSqlParser.RPAREN); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public kuduPartitionSpec(): KuduPartitionSpecContext { + let _localctx: KuduPartitionSpecContext = new KuduPartitionSpecContext(this._ctx, this.state); + this.enterRule(_localctx, 234, ImpalaSqlParser.RULE_kuduPartitionSpec); + let _la: number; + try { + this.state = 1759; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_VALUE: + this.enterOuterAlt(_localctx, 1); + { + this.state = 1744; + this.match(ImpalaSqlParser.KW_VALUE); + this.state = 1745; + this.partitionCol(); + this.state = 1746; + this.expression(); + } + break; + case ImpalaSqlParser.KW_ADD: + case ImpalaSqlParser.KW_ALL: + case ImpalaSqlParser.KW_ANY: + case ImpalaSqlParser.KW_ARRAY: + case ImpalaSqlParser.KW_ASC: + case ImpalaSqlParser.KW_AT: + case ImpalaSqlParser.KW_BERNOULLI: + case ImpalaSqlParser.KW_CASCADE: + case ImpalaSqlParser.KW_CASE: + case ImpalaSqlParser.KW_CAST: + case ImpalaSqlParser.KW_COLUMN: + case ImpalaSqlParser.KW_COLUMNS: + case ImpalaSqlParser.KW_COMMENT: + case ImpalaSqlParser.KW_CURRENT: + case ImpalaSqlParser.KW_CURRENT_DATE: + case ImpalaSqlParser.KW_CURRENT_PATH: + case ImpalaSqlParser.KW_CURRENT_TIME: + case ImpalaSqlParser.KW_CURRENT_TIMESTAMP: + case ImpalaSqlParser.KW_CURRENT_USER: + case ImpalaSqlParser.KW_DATA: + case ImpalaSqlParser.KW_DATABASE: + case ImpalaSqlParser.KW_DATABASES: + case ImpalaSqlParser.KW_DAY: + case ImpalaSqlParser.KW_DAYS: + case ImpalaSqlParser.KW_DEFAULT: + case ImpalaSqlParser.KW_DESC: + case ImpalaSqlParser.KW_EXCLUDING: + case ImpalaSqlParser.KW_EXISTS: + case ImpalaSqlParser.KW_EXPLAIN: + case ImpalaSqlParser.KW_EXTRACT: + case ImpalaSqlParser.KW_FALSE: + case ImpalaSqlParser.KW_FILTER: + case ImpalaSqlParser.KW_FIRST: + case ImpalaSqlParser.KW_FOLLOWING: + case ImpalaSqlParser.KW_FORMAT: + case ImpalaSqlParser.KW_FUNCTIONS: + case ImpalaSqlParser.KW_GRANT: + case ImpalaSqlParser.KW_GROUPING: + case ImpalaSqlParser.KW_HOUR: + case ImpalaSqlParser.KW_IF: + case ImpalaSqlParser.KW_INCLUDING: + case ImpalaSqlParser.KW_INTERVAL: + case ImpalaSqlParser.KW_LAST: + case ImpalaSqlParser.KW_LATERAL: + case ImpalaSqlParser.KW_LIMIT: + case ImpalaSqlParser.KW_LOCALTIME: + case ImpalaSqlParser.KW_LOCALTIMESTAMP: + case ImpalaSqlParser.KW_MAP: + case ImpalaSqlParser.KW_MINUTE: + case ImpalaSqlParser.KW_MONTH: + case ImpalaSqlParser.KW_NFC: + case ImpalaSqlParser.KW_NFD: + case ImpalaSqlParser.KW_NFKC: + case ImpalaSqlParser.KW_NFKD: + case ImpalaSqlParser.KW_NORMALIZE: + case ImpalaSqlParser.KW_NOT: + case ImpalaSqlParser.KW_NULL: + case ImpalaSqlParser.KW_NULLS: + case ImpalaSqlParser.KW_OFFSET: + case ImpalaSqlParser.KW_OPTION: + case ImpalaSqlParser.KW_ORDINALITY: + case ImpalaSqlParser.KW_OVER: + case ImpalaSqlParser.KW_PARTITION: + case ImpalaSqlParser.KW_PARTITIONS: + case ImpalaSqlParser.KW_PARQUET: + case ImpalaSqlParser.KW_POSITION: + case ImpalaSqlParser.KW_PRECEDING: + case ImpalaSqlParser.KW_PRIVILEGES: + case ImpalaSqlParser.KW_PROPERTIES: + case ImpalaSqlParser.KW_RANGE: + case ImpalaSqlParser.KW_RENAME: + case ImpalaSqlParser.KW_REPEATABLE: + case ImpalaSqlParser.KW_REPLACE: + case ImpalaSqlParser.KW_RESTRICT: + case ImpalaSqlParser.KW_REVOKE: + case ImpalaSqlParser.KW_ROLE: + case ImpalaSqlParser.KW_ROLES: + case ImpalaSqlParser.KW_ROW: + case ImpalaSqlParser.KW_ROWS: + case ImpalaSqlParser.KW_SCHEMA: + case ImpalaSqlParser.KW_SCHEMAS: + case ImpalaSqlParser.KW_SECOND: + case ImpalaSqlParser.KW_SECONDS: + case ImpalaSqlParser.KW_SET: + case ImpalaSqlParser.KW_SHOW: + case ImpalaSqlParser.KW_SOME: + case ImpalaSqlParser.KW_STATS: + case ImpalaSqlParser.KW_SUBSTRING: + case ImpalaSqlParser.KW_SYSTEM: + case ImpalaSqlParser.KW_TABLES: + case ImpalaSqlParser.KW_TABLESAMPLE: + case ImpalaSqlParser.KW_TO: + case ImpalaSqlParser.KW_TRUE: + case ImpalaSqlParser.KW_TRY_CAST: + case ImpalaSqlParser.KW_TRUNCATE: + case ImpalaSqlParser.KW_UNBOUNDED: + case ImpalaSqlParser.KW_USE: + case ImpalaSqlParser.KW_USER: + case ImpalaSqlParser.KW_VALUES: + case ImpalaSqlParser.KW_VIEW: + case ImpalaSqlParser.KW_VIEWS: + case ImpalaSqlParser.KW_YEAR: + case ImpalaSqlParser.KW_TEXTFILE: + case ImpalaSqlParser.KW_ORC: + case ImpalaSqlParser.KW_AVRO: + case ImpalaSqlParser.KW_SEQUENCEFILE: + case ImpalaSqlParser.KW_RCFILE: + case ImpalaSqlParser.PLUS: + case ImpalaSqlParser.MINUS: + case ImpalaSqlParser.LPAREN: + case ImpalaSqlParser.QUESTION: + case ImpalaSqlParser.STRING: + case ImpalaSqlParser.UNICODE_STRING: + case ImpalaSqlParser.BINARY_LITERAL: + case ImpalaSqlParser.INTEGER_VALUE: + case ImpalaSqlParser.DECIMAL_VALUE: + case ImpalaSqlParser.DOUBLE_VALUE: + case ImpalaSqlParser.IDENTIFIER: + case ImpalaSqlParser.DIGIT_IDENTIFIER: + case ImpalaSqlParser.BACKQUOTED_IDENTIFIER: + case ImpalaSqlParser.DOUBLE_PRECISION: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1751; + this._errHandler.sync(this); + _la = this._input.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ImpalaSqlParser.KW_ADD) | (1 << ImpalaSqlParser.KW_ALL) | (1 << ImpalaSqlParser.KW_ANY) | (1 << ImpalaSqlParser.KW_ARRAY) | (1 << ImpalaSqlParser.KW_ASC) | (1 << ImpalaSqlParser.KW_AT) | (1 << ImpalaSqlParser.KW_BERNOULLI) | (1 << ImpalaSqlParser.KW_CASCADE) | (1 << ImpalaSqlParser.KW_CASE) | (1 << ImpalaSqlParser.KW_CAST))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (ImpalaSqlParser.KW_COLUMN - 32)) | (1 << (ImpalaSqlParser.KW_COLUMNS - 32)) | (1 << (ImpalaSqlParser.KW_COMMENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_DATE - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_PATH - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_TIME - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_TIMESTAMP - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_USER - 32)) | (1 << (ImpalaSqlParser.KW_DATA - 32)) | (1 << (ImpalaSqlParser.KW_DATABASE - 32)) | (1 << (ImpalaSqlParser.KW_DATABASES - 32)) | (1 << (ImpalaSqlParser.KW_DAY - 32)) | (1 << (ImpalaSqlParser.KW_DAYS - 32)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 32)) | (1 << (ImpalaSqlParser.KW_DESC - 32)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (ImpalaSqlParser.KW_EXCLUDING - 65)) | (1 << (ImpalaSqlParser.KW_EXISTS - 65)) | (1 << (ImpalaSqlParser.KW_EXPLAIN - 65)) | (1 << (ImpalaSqlParser.KW_EXTRACT - 65)) | (1 << (ImpalaSqlParser.KW_FALSE - 65)) | (1 << (ImpalaSqlParser.KW_FILTER - 65)) | (1 << (ImpalaSqlParser.KW_FIRST - 65)) | (1 << (ImpalaSqlParser.KW_FOLLOWING - 65)) | (1 << (ImpalaSqlParser.KW_FORMAT - 65)) | (1 << (ImpalaSqlParser.KW_FUNCTIONS - 65)) | (1 << (ImpalaSqlParser.KW_GRANT - 65)) | (1 << (ImpalaSqlParser.KW_GROUPING - 65)) | (1 << (ImpalaSqlParser.KW_HOUR - 65)) | (1 << (ImpalaSqlParser.KW_IF - 65)) | (1 << (ImpalaSqlParser.KW_INCLUDING - 65)))) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (ImpalaSqlParser.KW_INTERVAL - 101)) | (1 << (ImpalaSqlParser.KW_LAST - 101)) | (1 << (ImpalaSqlParser.KW_LATERAL - 101)) | (1 << (ImpalaSqlParser.KW_LIMIT - 101)) | (1 << (ImpalaSqlParser.KW_LOCALTIME - 101)) | (1 << (ImpalaSqlParser.KW_LOCALTIMESTAMP - 101)) | (1 << (ImpalaSqlParser.KW_MAP - 101)) | (1 << (ImpalaSqlParser.KW_MINUTE - 101)) | (1 << (ImpalaSqlParser.KW_MONTH - 101)) | (1 << (ImpalaSqlParser.KW_NFC - 101)) | (1 << (ImpalaSqlParser.KW_NFD - 101)) | (1 << (ImpalaSqlParser.KW_NFKC - 101)) | (1 << (ImpalaSqlParser.KW_NFKD - 101)) | (1 << (ImpalaSqlParser.KW_NORMALIZE - 101)) | (1 << (ImpalaSqlParser.KW_NOT - 101)) | (1 << (ImpalaSqlParser.KW_NULL - 101)))) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & ((1 << (ImpalaSqlParser.KW_NULLS - 133)) | (1 << (ImpalaSqlParser.KW_OFFSET - 133)) | (1 << (ImpalaSqlParser.KW_OPTION - 133)) | (1 << (ImpalaSqlParser.KW_ORDINALITY - 133)) | (1 << (ImpalaSqlParser.KW_OVER - 133)) | (1 << (ImpalaSqlParser.KW_PARTITION - 133)) | (1 << (ImpalaSqlParser.KW_PARTITIONS - 133)) | (1 << (ImpalaSqlParser.KW_PARQUET - 133)) | (1 << (ImpalaSqlParser.KW_POSITION - 133)) | (1 << (ImpalaSqlParser.KW_PRECEDING - 133)) | (1 << (ImpalaSqlParser.KW_PRIVILEGES - 133)) | (1 << (ImpalaSqlParser.KW_PROPERTIES - 133)) | (1 << (ImpalaSqlParser.KW_RANGE - 133)) | (1 << (ImpalaSqlParser.KW_RENAME - 133)) | (1 << (ImpalaSqlParser.KW_REPEATABLE - 133)) | (1 << (ImpalaSqlParser.KW_REPLACE - 133)) | (1 << (ImpalaSqlParser.KW_RESTRICT - 133)) | (1 << (ImpalaSqlParser.KW_REVOKE - 133)))) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & ((1 << (ImpalaSqlParser.KW_ROLE - 165)) | (1 << (ImpalaSqlParser.KW_ROLES - 165)) | (1 << (ImpalaSqlParser.KW_ROW - 165)) | (1 << (ImpalaSqlParser.KW_ROWS - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMA - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMAS - 165)) | (1 << (ImpalaSqlParser.KW_SECOND - 165)) | (1 << (ImpalaSqlParser.KW_SECONDS - 165)) | (1 << (ImpalaSqlParser.KW_SET - 165)) | (1 << (ImpalaSqlParser.KW_SHOW - 165)) | (1 << (ImpalaSqlParser.KW_SOME - 165)) | (1 << (ImpalaSqlParser.KW_STATS - 165)) | (1 << (ImpalaSqlParser.KW_SUBSTRING - 165)) | (1 << (ImpalaSqlParser.KW_SYSTEM - 165)) | (1 << (ImpalaSqlParser.KW_TABLES - 165)) | (1 << (ImpalaSqlParser.KW_TABLESAMPLE - 165)) | (1 << (ImpalaSqlParser.KW_TO - 165)) | (1 << (ImpalaSqlParser.KW_TRUE - 165)) | (1 << (ImpalaSqlParser.KW_TRY_CAST - 165)) | (1 << (ImpalaSqlParser.KW_TRUNCATE - 165)))) !== 0) || ((((_la - 199)) & ~0x1F) === 0 && ((1 << (_la - 199)) & ((1 << (ImpalaSqlParser.KW_UNBOUNDED - 199)) | (1 << (ImpalaSqlParser.KW_USE - 199)) | (1 << (ImpalaSqlParser.KW_USER - 199)) | (1 << (ImpalaSqlParser.KW_VIEW - 199)) | (1 << (ImpalaSqlParser.KW_VIEWS - 199)) | (1 << (ImpalaSqlParser.KW_YEAR - 199)) | (1 << (ImpalaSqlParser.KW_TEXTFILE - 199)) | (1 << (ImpalaSqlParser.KW_ORC - 199)) | (1 << (ImpalaSqlParser.KW_AVRO - 199)) | (1 << (ImpalaSqlParser.KW_SEQUENCEFILE - 199)) | (1 << (ImpalaSqlParser.KW_RCFILE - 199)))) !== 0) || ((((_la - 236)) & ~0x1F) === 0 && ((1 << (_la - 236)) & ((1 << (ImpalaSqlParser.PLUS - 236)) | (1 << (ImpalaSqlParser.MINUS - 236)) | (1 << (ImpalaSqlParser.LPAREN - 236)) | (1 << (ImpalaSqlParser.QUESTION - 236)) | (1 << (ImpalaSqlParser.STRING - 236)) | (1 << (ImpalaSqlParser.UNICODE_STRING - 236)) | (1 << (ImpalaSqlParser.BINARY_LITERAL - 236)) | (1 << (ImpalaSqlParser.INTEGER_VALUE - 236)) | (1 << (ImpalaSqlParser.DECIMAL_VALUE - 236)) | (1 << (ImpalaSqlParser.DOUBLE_VALUE - 236)) | (1 << (ImpalaSqlParser.IDENTIFIER - 236)) | (1 << (ImpalaSqlParser.DIGIT_IDENTIFIER - 236)) | (1 << (ImpalaSqlParser.BACKQUOTED_IDENTIFIER - 236)) | (1 << (ImpalaSqlParser.DOUBLE_PRECISION - 236)))) !== 0)) { + { + this.state = 1748; + this.expression(); + this.state = 1749; + this.rangeOperator(); + } + } + + this.state = 1753; + this.match(ImpalaSqlParser.KW_VALUES); + this.state = 1757; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 208, this._ctx) ) { + case 1: + { + this.state = 1754; + this.rangeOperator(); + this.state = 1755; + this.expression(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public cacheSpec(): CacheSpecContext { + let _localctx: CacheSpecContext = new CacheSpecContext(this._ctx, this.state); + this.enterRule(_localctx, 236, ImpalaSqlParser.RULE_cacheSpec); + try { + this.state = 1771; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_CACHED: + this.enterOuterAlt(_localctx, 1); + { + this.state = 1761; + this.match(ImpalaSqlParser.KW_CACHED); + this.state = 1762; + this.match(ImpalaSqlParser.KW_IN); + this.state = 1763; + this.identifier(); + this.state = 1768; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 210, this._ctx) ) { + case 1: + { + this.state = 1764; + this.match(ImpalaSqlParser.KW_WITH); + this.state = 1765; + this.match(ImpalaSqlParser.KW_REPLICATION); + this.state = 1766; + this.match(ImpalaSqlParser.EQ); + this.state = 1767; + this.number(); + } + break; + } + } + break; + case ImpalaSqlParser.KW_UNCACHED: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1770; + this.match(ImpalaSqlParser.KW_UNCACHED); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public rangeOperator(): RangeOperatorContext { + let _localctx: RangeOperatorContext = new RangeOperatorContext(this._ctx, this.state); + this.enterRule(_localctx, 238, ImpalaSqlParser.RULE_rangeOperator); + try { + this.state = 1778; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_ADD: + case ImpalaSqlParser.KW_ALL: + case ImpalaSqlParser.KW_ANY: + case ImpalaSqlParser.KW_ARRAY: + case ImpalaSqlParser.KW_ASC: + case ImpalaSqlParser.KW_AT: + case ImpalaSqlParser.KW_BERNOULLI: + case ImpalaSqlParser.KW_CASCADE: + case ImpalaSqlParser.KW_CASE: + case ImpalaSqlParser.KW_CAST: + case ImpalaSqlParser.KW_COLUMN: + case ImpalaSqlParser.KW_COLUMNS: + case ImpalaSqlParser.KW_COMMENT: + case ImpalaSqlParser.KW_CURRENT: + case ImpalaSqlParser.KW_CURRENT_DATE: + case ImpalaSqlParser.KW_CURRENT_PATH: + case ImpalaSqlParser.KW_CURRENT_TIME: + case ImpalaSqlParser.KW_CURRENT_TIMESTAMP: + case ImpalaSqlParser.KW_CURRENT_USER: + case ImpalaSqlParser.KW_DATA: + case ImpalaSqlParser.KW_DATABASE: + case ImpalaSqlParser.KW_DATABASES: + case ImpalaSqlParser.KW_DAY: + case ImpalaSqlParser.KW_DAYS: + case ImpalaSqlParser.KW_DEFAULT: + case ImpalaSqlParser.KW_DESC: + case ImpalaSqlParser.KW_EXCLUDING: + case ImpalaSqlParser.KW_EXISTS: + case ImpalaSqlParser.KW_EXPLAIN: + case ImpalaSqlParser.KW_EXTRACT: + case ImpalaSqlParser.KW_FALSE: + case ImpalaSqlParser.KW_FILTER: + case ImpalaSqlParser.KW_FIRST: + case ImpalaSqlParser.KW_FOLLOWING: + case ImpalaSqlParser.KW_FORMAT: + case ImpalaSqlParser.KW_FUNCTIONS: + case ImpalaSqlParser.KW_GRANT: + case ImpalaSqlParser.KW_GROUPING: + case ImpalaSqlParser.KW_HOUR: + case ImpalaSqlParser.KW_IF: + case ImpalaSqlParser.KW_INCLUDING: + case ImpalaSqlParser.KW_INTERVAL: + case ImpalaSqlParser.KW_LAST: + case ImpalaSqlParser.KW_LATERAL: + case ImpalaSqlParser.KW_LIMIT: + case ImpalaSqlParser.KW_LOCALTIME: + case ImpalaSqlParser.KW_LOCALTIMESTAMP: + case ImpalaSqlParser.KW_MAP: + case ImpalaSqlParser.KW_MINUTE: + case ImpalaSqlParser.KW_MONTH: + case ImpalaSqlParser.KW_NFC: + case ImpalaSqlParser.KW_NFD: + case ImpalaSqlParser.KW_NFKC: + case ImpalaSqlParser.KW_NFKD: + case ImpalaSqlParser.KW_NORMALIZE: + case ImpalaSqlParser.KW_NOT: + case ImpalaSqlParser.KW_NULL: + case ImpalaSqlParser.KW_NULLS: + case ImpalaSqlParser.KW_OFFSET: + case ImpalaSqlParser.KW_OPTION: + case ImpalaSqlParser.KW_ORDINALITY: + case ImpalaSqlParser.KW_OVER: + case ImpalaSqlParser.KW_PARTITION: + case ImpalaSqlParser.KW_PARTITIONS: + case ImpalaSqlParser.KW_PARQUET: + case ImpalaSqlParser.KW_POSITION: + case ImpalaSqlParser.KW_PRECEDING: + case ImpalaSqlParser.KW_PRIVILEGES: + case ImpalaSqlParser.KW_PROPERTIES: + case ImpalaSqlParser.KW_RANGE: + case ImpalaSqlParser.KW_RENAME: + case ImpalaSqlParser.KW_REPEATABLE: + case ImpalaSqlParser.KW_REPLACE: + case ImpalaSqlParser.KW_RESTRICT: + case ImpalaSqlParser.KW_REVOKE: + case ImpalaSqlParser.KW_ROLE: + case ImpalaSqlParser.KW_ROLES: + case ImpalaSqlParser.KW_ROW: + case ImpalaSqlParser.KW_ROWS: + case ImpalaSqlParser.KW_SCHEMA: + case ImpalaSqlParser.KW_SCHEMAS: + case ImpalaSqlParser.KW_SECOND: + case ImpalaSqlParser.KW_SECONDS: + case ImpalaSqlParser.KW_SET: + case ImpalaSqlParser.KW_SHOW: + case ImpalaSqlParser.KW_SOME: + case ImpalaSqlParser.KW_STATS: + case ImpalaSqlParser.KW_SUBSTRING: + case ImpalaSqlParser.KW_SYSTEM: + case ImpalaSqlParser.KW_TABLES: + case ImpalaSqlParser.KW_TABLESAMPLE: + case ImpalaSqlParser.KW_TO: + case ImpalaSqlParser.KW_TRUE: + case ImpalaSqlParser.KW_TRY_CAST: + case ImpalaSqlParser.KW_TRUNCATE: + case ImpalaSqlParser.KW_UNBOUNDED: + case ImpalaSqlParser.KW_USE: + case ImpalaSqlParser.KW_USER: + case ImpalaSqlParser.KW_VALUES: + case ImpalaSqlParser.KW_VIEW: + case ImpalaSqlParser.KW_VIEWS: + case ImpalaSqlParser.KW_YEAR: + case ImpalaSqlParser.KW_TEXTFILE: + case ImpalaSqlParser.KW_ORC: + case ImpalaSqlParser.KW_AVRO: + case ImpalaSqlParser.KW_SEQUENCEFILE: + case ImpalaSqlParser.KW_RCFILE: + case ImpalaSqlParser.PLUS: + case ImpalaSqlParser.MINUS: + case ImpalaSqlParser.LPAREN: + case ImpalaSqlParser.QUESTION: + case ImpalaSqlParser.STRING: + case ImpalaSqlParser.UNICODE_STRING: + case ImpalaSqlParser.BINARY_LITERAL: + case ImpalaSqlParser.INTEGER_VALUE: + case ImpalaSqlParser.DECIMAL_VALUE: + case ImpalaSqlParser.DOUBLE_VALUE: + case ImpalaSqlParser.IDENTIFIER: + case ImpalaSqlParser.DIGIT_IDENTIFIER: + case ImpalaSqlParser.BACKQUOTED_IDENTIFIER: + case ImpalaSqlParser.DOUBLE_PRECISION: + this.enterOuterAlt(_localctx, 1); + // tslint:disable-next-line:no-empty + { + } + break; + case ImpalaSqlParser.LT: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1774; + this.match(ImpalaSqlParser.LT); + } + break; + case ImpalaSqlParser.LTE: + this.enterOuterAlt(_localctx, 3); + { + this.state = 1775; + this.match(ImpalaSqlParser.LTE); + } + break; + case ImpalaSqlParser.GT: + this.enterOuterAlt(_localctx, 4); + { + this.state = 1776; + this.match(ImpalaSqlParser.GT); + } + break; + case ImpalaSqlParser.GTE: + this.enterOuterAlt(_localctx, 5); + { + this.state = 1777; + this.match(ImpalaSqlParser.GTE); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public partitionCol(): PartitionColContext { + let _localctx: PartitionColContext = new PartitionColContext(this._ctx, this.state); + this.enterRule(_localctx, 240, ImpalaSqlParser.RULE_partitionCol); + try { + this.state = 1788; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.EQ: + this.enterOuterAlt(_localctx, 1); + { + this.state = 1780; + this.match(ImpalaSqlParser.EQ); + } + break; + case ImpalaSqlParser.NEQ: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1781; + this.match(ImpalaSqlParser.NEQ); + } + break; + case ImpalaSqlParser.KW_LIKE: + this.enterOuterAlt(_localctx, 3); + { + this.state = 1782; + this.match(ImpalaSqlParser.KW_LIKE); + } + break; + case ImpalaSqlParser.KW_RLIKE: + this.enterOuterAlt(_localctx, 4); + { + this.state = 1783; + this.match(ImpalaSqlParser.KW_RLIKE); + } + break; + case ImpalaSqlParser.KW_REGEXP: + this.enterOuterAlt(_localctx, 5); + { + this.state = 1784; + this.match(ImpalaSqlParser.KW_REGEXP); + } + break; + case ImpalaSqlParser.KW_BETWEEN: + this.enterOuterAlt(_localctx, 6); + { + this.state = 1785; + this.match(ImpalaSqlParser.KW_BETWEEN); + } + break; + case ImpalaSqlParser.KW_IN: + this.enterOuterAlt(_localctx, 7); + { + this.state = 1786; + this.match(ImpalaSqlParser.KW_IN); + } + break; + case ImpalaSqlParser.KW_ADD: + case ImpalaSqlParser.KW_ALL: + case ImpalaSqlParser.KW_ANY: + case ImpalaSqlParser.KW_ARRAY: + case ImpalaSqlParser.KW_ASC: + case ImpalaSqlParser.KW_AT: + case ImpalaSqlParser.KW_BERNOULLI: + case ImpalaSqlParser.KW_CASCADE: + case ImpalaSqlParser.KW_CASE: + case ImpalaSqlParser.KW_CAST: + case ImpalaSqlParser.KW_COLUMN: + case ImpalaSqlParser.KW_COLUMNS: + case ImpalaSqlParser.KW_COMMENT: + case ImpalaSqlParser.KW_CURRENT: + case ImpalaSqlParser.KW_CURRENT_DATE: + case ImpalaSqlParser.KW_CURRENT_PATH: + case ImpalaSqlParser.KW_CURRENT_TIME: + case ImpalaSqlParser.KW_CURRENT_TIMESTAMP: + case ImpalaSqlParser.KW_CURRENT_USER: + case ImpalaSqlParser.KW_DATA: + case ImpalaSqlParser.KW_DATABASE: + case ImpalaSqlParser.KW_DATABASES: + case ImpalaSqlParser.KW_DAY: + case ImpalaSqlParser.KW_DAYS: + case ImpalaSqlParser.KW_DEFAULT: + case ImpalaSqlParser.KW_DESC: + case ImpalaSqlParser.KW_EXCLUDING: + case ImpalaSqlParser.KW_EXISTS: + case ImpalaSqlParser.KW_EXPLAIN: + case ImpalaSqlParser.KW_EXTRACT: + case ImpalaSqlParser.KW_FALSE: + case ImpalaSqlParser.KW_FILTER: + case ImpalaSqlParser.KW_FIRST: + case ImpalaSqlParser.KW_FOLLOWING: + case ImpalaSqlParser.KW_FORMAT: + case ImpalaSqlParser.KW_FUNCTIONS: + case ImpalaSqlParser.KW_GRANT: + case ImpalaSqlParser.KW_GROUPING: + case ImpalaSqlParser.KW_HOUR: + case ImpalaSqlParser.KW_IF: + case ImpalaSqlParser.KW_INCLUDING: + case ImpalaSqlParser.KW_INTERVAL: + case ImpalaSqlParser.KW_LAST: + case ImpalaSqlParser.KW_LATERAL: + case ImpalaSqlParser.KW_LIMIT: + case ImpalaSqlParser.KW_LOCALTIME: + case ImpalaSqlParser.KW_LOCALTIMESTAMP: + case ImpalaSqlParser.KW_MAP: + case ImpalaSqlParser.KW_MINUTE: + case ImpalaSqlParser.KW_MONTH: + case ImpalaSqlParser.KW_NFC: + case ImpalaSqlParser.KW_NFD: + case ImpalaSqlParser.KW_NFKC: + case ImpalaSqlParser.KW_NFKD: + case ImpalaSqlParser.KW_NORMALIZE: + case ImpalaSqlParser.KW_NOT: + case ImpalaSqlParser.KW_NULL: + case ImpalaSqlParser.KW_NULLS: + case ImpalaSqlParser.KW_OFFSET: + case ImpalaSqlParser.KW_OPTION: + case ImpalaSqlParser.KW_ORDINALITY: + case ImpalaSqlParser.KW_OVER: + case ImpalaSqlParser.KW_PARTITION: + case ImpalaSqlParser.KW_PARTITIONS: + case ImpalaSqlParser.KW_PARQUET: + case ImpalaSqlParser.KW_POSITION: + case ImpalaSqlParser.KW_PRECEDING: + case ImpalaSqlParser.KW_PRIVILEGES: + case ImpalaSqlParser.KW_PROPERTIES: + case ImpalaSqlParser.KW_RANGE: + case ImpalaSqlParser.KW_RENAME: + case ImpalaSqlParser.KW_REPEATABLE: + case ImpalaSqlParser.KW_REPLACE: + case ImpalaSqlParser.KW_RESTRICT: + case ImpalaSqlParser.KW_REVOKE: + case ImpalaSqlParser.KW_ROLE: + case ImpalaSqlParser.KW_ROLES: + case ImpalaSqlParser.KW_ROW: + case ImpalaSqlParser.KW_ROWS: + case ImpalaSqlParser.KW_SCHEMA: + case ImpalaSqlParser.KW_SCHEMAS: + case ImpalaSqlParser.KW_SECOND: + case ImpalaSqlParser.KW_SECONDS: + case ImpalaSqlParser.KW_SET: + case ImpalaSqlParser.KW_SHOW: + case ImpalaSqlParser.KW_SOME: + case ImpalaSqlParser.KW_STATS: + case ImpalaSqlParser.KW_SUBSTRING: + case ImpalaSqlParser.KW_SYSTEM: + case ImpalaSqlParser.KW_TABLES: + case ImpalaSqlParser.KW_TABLESAMPLE: + case ImpalaSqlParser.KW_TO: + case ImpalaSqlParser.KW_TRUE: + case ImpalaSqlParser.KW_TRY_CAST: + case ImpalaSqlParser.KW_TRUNCATE: + case ImpalaSqlParser.KW_UNBOUNDED: + case ImpalaSqlParser.KW_USE: + case ImpalaSqlParser.KW_USER: + case ImpalaSqlParser.KW_VALUES: + case ImpalaSqlParser.KW_VIEW: + case ImpalaSqlParser.KW_VIEWS: + case ImpalaSqlParser.KW_YEAR: + case ImpalaSqlParser.KW_TEXTFILE: + case ImpalaSqlParser.KW_ORC: + case ImpalaSqlParser.KW_AVRO: + case ImpalaSqlParser.KW_SEQUENCEFILE: + case ImpalaSqlParser.KW_RCFILE: + case ImpalaSqlParser.LT: + case ImpalaSqlParser.LTE: + case ImpalaSqlParser.GT: + case ImpalaSqlParser.GTE: + case ImpalaSqlParser.PLUS: + case ImpalaSqlParser.MINUS: + case ImpalaSqlParser.LPAREN: + case ImpalaSqlParser.QUESTION: + case ImpalaSqlParser.STRING: + case ImpalaSqlParser.UNICODE_STRING: + case ImpalaSqlParser.BINARY_LITERAL: + case ImpalaSqlParser.INTEGER_VALUE: + case ImpalaSqlParser.DECIMAL_VALUE: + case ImpalaSqlParser.DOUBLE_VALUE: + case ImpalaSqlParser.IDENTIFIER: + case ImpalaSqlParser.DIGIT_IDENTIFIER: + case ImpalaSqlParser.BACKQUOTED_IDENTIFIER: + case ImpalaSqlParser.DOUBLE_PRECISION: + this.enterOuterAlt(_localctx, 8); + { + this.state = 1787; + this.rangeOperator(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public likeClause(): LikeClauseContext { + let _localctx: LikeClauseContext = new LikeClauseContext(this._ctx, this.state); + this.enterRule(_localctx, 242, ImpalaSqlParser.RULE_likeClause); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1790; + this.match(ImpalaSqlParser.KW_LIKE); + this.state = 1791; + this.qualifiedName(); + this.state = 1794; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_EXCLUDING || _la === ImpalaSqlParser.KW_INCLUDING) { + { + this.state = 1792; + _localctx._optionType = this._input.LT(1); + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_EXCLUDING || _la === ImpalaSqlParser.KW_INCLUDING)) { + _localctx._optionType = this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1793; + this.match(ImpalaSqlParser.KW_PROPERTIES); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public properties(): PropertiesContext { + let _localctx: PropertiesContext = new PropertiesContext(this._ctx, this.state); + this.enterRule(_localctx, 244, ImpalaSqlParser.RULE_properties); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1796; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1797; + this.property(); + this.state = 1802; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 1798; + this.match(ImpalaSqlParser.COMMA); + this.state = 1799; + this.property(); + } + } + this.state = 1804; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 1805; + this.match(ImpalaSqlParser.RPAREN); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public partitionedBy(): PartitionedByContext { + let _localctx: PartitionedByContext = new PartitionedByContext(this._ctx, this.state); + this.enterRule(_localctx, 246, ImpalaSqlParser.RULE_partitionedBy); + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 1807; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1808; + this.columnDefinition(); + this.state = 1813; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 216, this._ctx); + while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1 + 1) { + { + { + this.state = 1809; + this.match(ImpalaSqlParser.COMMA); + this.state = 1810; + this.columnDefinition(); + } + } + } + this.state = 1815; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 216, this._ctx); + } + this.state = 1816; + this.match(ImpalaSqlParser.RPAREN); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public sortedBy(): SortedByContext { + let _localctx: SortedByContext = new SortedByContext(this._ctx, this.state); + this.enterRule(_localctx, 248, ImpalaSqlParser.RULE_sortedBy); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1818; + this.expression(); + this.state = 1823; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 1819; + this.match(ImpalaSqlParser.COMMA); + this.state = 1820; + this.expression(); + } + } + this.state = 1825; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public rowFormat(): RowFormatContext { + let _localctx: RowFormatContext = new RowFormatContext(this._ctx, this.state); + this.enterRule(_localctx, 250, ImpalaSqlParser.RULE_rowFormat); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1826; + this.match(ImpalaSqlParser.KW_DELIMITED); + this.state = 1836; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_FIELDS) { + { + this.state = 1827; + this.match(ImpalaSqlParser.KW_FIELDS); + this.state = 1828; + this.match(ImpalaSqlParser.KW_TERMINATED); + this.state = 1829; + this.match(ImpalaSqlParser.KW_BY); + this.state = 1830; + this.stringLiteral(); + this.state = 1834; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ESCAPED) { + { + this.state = 1831; + this.match(ImpalaSqlParser.KW_ESCAPED); + this.state = 1832; + this.match(ImpalaSqlParser.KW_BY); + this.state = 1833; + this.stringLiteral(); + } + } + + } + } + + this.state = 1842; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_LINES) { + { + this.state = 1838; + this.match(ImpalaSqlParser.KW_LINES); + this.state = 1839; + this.match(ImpalaSqlParser.KW_TERMINATED); + this.state = 1840; + this.match(ImpalaSqlParser.KW_BY); + this.state = 1841; + this.stringLiteral(); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public property(): PropertyContext { + let _localctx: PropertyContext = new PropertyContext(this._ctx, this.state); + this.enterRule(_localctx, 252, ImpalaSqlParser.RULE_property); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1844; + this.identifier(); + this.state = 1847; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.EQ) { + { + this.state = 1845; + this.match(ImpalaSqlParser.EQ); + this.state = 1846; + this.expression(); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public queryNoWith(): QueryNoWithContext { + let _localctx: QueryNoWithContext = new QueryNoWithContext(this._ctx, this.state); + this.enterRule(_localctx, 254, ImpalaSqlParser.RULE_queryNoWith); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1849; + this.queryTerm(0); + this.state = 1860; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ORDER) { + { + this.state = 1850; + this.match(ImpalaSqlParser.KW_ORDER); + this.state = 1851; + this.match(ImpalaSqlParser.KW_BY); + this.state = 1852; + this.sortItem(); + this.state = 1857; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 1853; + this.match(ImpalaSqlParser.COMMA); + this.state = 1854; + this.sortItem(); + } + } + this.state = 1859; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + this.state = 1868; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_LIMIT) { + { + this.state = 1862; + this.match(ImpalaSqlParser.KW_LIMIT); + this.state = 1863; + _localctx._rows = this.expression(); + this.state = 1866; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_OFFSET) { + { + this.state = 1864; + this.match(ImpalaSqlParser.KW_OFFSET); + this.state = 1865; + _localctx._offset = this.match(ImpalaSqlParser.INTEGER_VALUE); + } + } + + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + + public queryTerm(): QueryTermContext; + public queryTerm(_p: number): QueryTermContext; + // @RuleVersion(0) + public queryTerm(_p?: number): QueryTermContext { + if (_p === undefined) { + _p = 0; + } + + let _parentctx: ParserRuleContext = this._ctx; + let _parentState: number = this.state; + let _localctx: QueryTermContext = new QueryTermContext(this._ctx, _parentState); + let _prevctx: QueryTermContext = _localctx; + let _startState: number = 256; + this.enterRecursionRule(_localctx, 256, ImpalaSqlParser.RULE_queryTerm, _p); + let _la: number; + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + { + _localctx = new QueryTermDefaultContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + + this.state = 1871; + this.queryPrimary(); + } + this._ctx._stop = this._input.tryLT(-1); + this.state = 1887; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 229, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + if (this._parseListeners != null) { + this.triggerExitRuleEvent(); + } + _prevctx = _localctx; + { + this.state = 1885; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 228, this._ctx) ) { + case 1: + { + _localctx = new SetOperationContext(new QueryTermContext(_parentctx, _parentState)); + (_localctx as SetOperationContext)._left = _prevctx; + this.pushNewRecursionContext(_localctx, _startState, ImpalaSqlParser.RULE_queryTerm); + this.state = 1873; + if (!(this.precpred(this._ctx, 2))) { + throw this.createFailedPredicateException("this.precpred(this._ctx, 2)"); + } + this.state = 1874; + (_localctx as SetOperationContext)._operator = this.match(ImpalaSqlParser.KW_INTERSECT); + this.state = 1876; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ALL || _la === ImpalaSqlParser.KW_DISTINCT) { + { + this.state = 1875; + this.setQuantifier(); + } + } + + this.state = 1878; + (_localctx as SetOperationContext)._right = this.queryTerm(3); + } + break; + + case 2: + { + _localctx = new SetOperationContext(new QueryTermContext(_parentctx, _parentState)); + (_localctx as SetOperationContext)._left = _prevctx; + this.pushNewRecursionContext(_localctx, _startState, ImpalaSqlParser.RULE_queryTerm); + this.state = 1879; + if (!(this.precpred(this._ctx, 1))) { + throw this.createFailedPredicateException("this.precpred(this._ctx, 1)"); + } + this.state = 1880; + (_localctx as SetOperationContext)._operator = this._input.LT(1); + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_EXCEPT || _la === ImpalaSqlParser.KW_UNION)) { + (_localctx as SetOperationContext)._operator = this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1882; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ALL || _la === ImpalaSqlParser.KW_DISTINCT) { + { + this.state = 1881; + this.setQuantifier(); + } + } + + this.state = 1884; + (_localctx as SetOperationContext)._right = this.queryTerm(2); + } + break; + } + } + } + this.state = 1889; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 229, this._ctx); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.unrollRecursionContexts(_parentctx); + } + return _localctx; + } + // @RuleVersion(0) + public queryPrimary(): QueryPrimaryContext { + let _localctx: QueryPrimaryContext = new QueryPrimaryContext(this._ctx, this.state); + this.enterRule(_localctx, 258, ImpalaSqlParser.RULE_queryPrimary); + try { + let _alt: number; + this.state = 1906; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_SELECT: + _localctx = new QueryPrimaryDefaultContext(_localctx); + this.enterOuterAlt(_localctx, 1); + { + this.state = 1890; + this.querySpecification(); + } + break; + case ImpalaSqlParser.KW_TABLE: + _localctx = new TableContext(_localctx); + this.enterOuterAlt(_localctx, 2); + { + this.state = 1891; + this.match(ImpalaSqlParser.KW_TABLE); + this.state = 1892; + this.tableNamePath(); + } + break; + case ImpalaSqlParser.KW_VALUES: + _localctx = new InlineTableContext(_localctx); + this.enterOuterAlt(_localctx, 3); + { + this.state = 1893; + this.match(ImpalaSqlParser.KW_VALUES); + this.state = 1894; + this.expression(); + this.state = 1899; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 230, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + { + { + this.state = 1895; + this.match(ImpalaSqlParser.COMMA); + this.state = 1896; + this.expression(); + } + } + } + this.state = 1901; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 230, this._ctx); + } + } + break; + case ImpalaSqlParser.LPAREN: + _localctx = new SubqueryContext(_localctx); + this.enterOuterAlt(_localctx, 4); + { + this.state = 1902; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1903; + this.queryNoWith(); + this.state = 1904; + this.match(ImpalaSqlParser.RPAREN); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public sortItem(): SortItemContext { + let _localctx: SortItemContext = new SortItemContext(this._ctx, this.state); + this.enterRule(_localctx, 260, ImpalaSqlParser.RULE_sortItem); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1908; + this.columnItem(); + this.state = 1910; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ASC || _la === ImpalaSqlParser.KW_DESC) { + { + this.state = 1909; + _localctx._ordering = this._input.LT(1); + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_ASC || _la === ImpalaSqlParser.KW_DESC)) { + _localctx._ordering = this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 1914; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_NULLS) { + { + this.state = 1912; + this.match(ImpalaSqlParser.KW_NULLS); + this.state = 1913; + _localctx._nullOrdering = this._input.LT(1); + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_FIRST || _la === ImpalaSqlParser.KW_LAST)) { + _localctx._nullOrdering = this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public querySpecification(): QuerySpecificationContext { + let _localctx: QuerySpecificationContext = new QuerySpecificationContext(this._ctx, this.state); + this.enterRule(_localctx, 262, ImpalaSqlParser.RULE_querySpecification); + let _la: number; + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 1916; + this.match(ImpalaSqlParser.KW_SELECT); + this.state = 1918; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 234, this._ctx) ) { + case 1: + { + this.state = 1917; + this.setQuantifier(); + } + break; + } + this.state = 1921; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_STRAIGHT_JOIN) { + { + this.state = 1920; + this.match(ImpalaSqlParser.KW_STRAIGHT_JOIN); + } + } + + this.state = 1923; + this.selectItem(); + this.state = 1928; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 236, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + { + { + this.state = 1924; + this.match(ImpalaSqlParser.COMMA); + this.state = 1925; + this.selectItem(); + } + } + } + this.state = 1930; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 236, this._ctx); + } + this.state = 1940; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 238, this._ctx) ) { + case 1: + { + this.state = 1931; + this.match(ImpalaSqlParser.KW_FROM); + this.state = 1932; + this.relation(0); + this.state = 1937; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 237, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + { + { + this.state = 1933; + this.match(ImpalaSqlParser.COMMA); + this.state = 1934; + this.relation(0); + } + } + } + this.state = 1939; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 237, this._ctx); + } + } + break; + } + this.state = 1944; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 239, this._ctx) ) { + case 1: + { + this.state = 1942; + this.match(ImpalaSqlParser.KW_WHERE); + this.state = 1943; + _localctx._where = this.booleanExpression(0); + } + break; + } + this.state = 1949; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 240, this._ctx) ) { + case 1: + { + this.state = 1946; + this.match(ImpalaSqlParser.KW_GROUP); + this.state = 1947; + this.match(ImpalaSqlParser.KW_BY); + this.state = 1948; + this.groupBy(); + } + break; + } + this.state = 1953; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 241, this._ctx) ) { + case 1: + { + this.state = 1951; + this.match(ImpalaSqlParser.KW_HAVING); + this.state = 1952; + _localctx._having = this.booleanExpression(0); + } + break; + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public groupBy(): GroupByContext { + let _localctx: GroupByContext = new GroupByContext(this._ctx, this.state); + this.enterRule(_localctx, 264, ImpalaSqlParser.RULE_groupBy); + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 1956; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 242, this._ctx) ) { + case 1: + { + this.state = 1955; + this.setQuantifier(); + } + break; + } + this.state = 1958; + this.groupingElement(); + this.state = 1963; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 243, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + { + { + this.state = 1959; + this.match(ImpalaSqlParser.COMMA); + this.state = 1960; + this.groupingElement(); + } + } + } + this.state = 1965; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 243, this._ctx); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public groupingElement(): GroupingElementContext { + let _localctx: GroupingElementContext = new GroupingElementContext(this._ctx, this.state); + this.enterRule(_localctx, 266, ImpalaSqlParser.RULE_groupingElement); + try { + _localctx = new SingleGroupingSetContext(_localctx); + this.enterOuterAlt(_localctx, 1); + { + this.state = 1966; + this.groupingSet(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public groupingSet(): GroupingSetContext { + let _localctx: GroupingSetContext = new GroupingSetContext(this._ctx, this.state); + this.enterRule(_localctx, 268, ImpalaSqlParser.RULE_groupingSet); + let _la: number; + try { + this.state = 1981; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 246, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 1968; + this.match(ImpalaSqlParser.LPAREN); + this.state = 1977; + this._errHandler.sync(this); + _la = this._input.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ImpalaSqlParser.KW_ADD) | (1 << ImpalaSqlParser.KW_ALL) | (1 << ImpalaSqlParser.KW_ANY) | (1 << ImpalaSqlParser.KW_ARRAY) | (1 << ImpalaSqlParser.KW_ASC) | (1 << ImpalaSqlParser.KW_AT) | (1 << ImpalaSqlParser.KW_BERNOULLI) | (1 << ImpalaSqlParser.KW_CASCADE) | (1 << ImpalaSqlParser.KW_CASE) | (1 << ImpalaSqlParser.KW_CAST))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (ImpalaSqlParser.KW_COLUMN - 32)) | (1 << (ImpalaSqlParser.KW_COLUMNS - 32)) | (1 << (ImpalaSqlParser.KW_COMMENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_DATE - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_PATH - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_TIME - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_TIMESTAMP - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_USER - 32)) | (1 << (ImpalaSqlParser.KW_DATA - 32)) | (1 << (ImpalaSqlParser.KW_DATABASE - 32)) | (1 << (ImpalaSqlParser.KW_DATABASES - 32)) | (1 << (ImpalaSqlParser.KW_DAY - 32)) | (1 << (ImpalaSqlParser.KW_DAYS - 32)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 32)) | (1 << (ImpalaSqlParser.KW_DESC - 32)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (ImpalaSqlParser.KW_EXCLUDING - 65)) | (1 << (ImpalaSqlParser.KW_EXISTS - 65)) | (1 << (ImpalaSqlParser.KW_EXPLAIN - 65)) | (1 << (ImpalaSqlParser.KW_EXTRACT - 65)) | (1 << (ImpalaSqlParser.KW_FALSE - 65)) | (1 << (ImpalaSqlParser.KW_FILTER - 65)) | (1 << (ImpalaSqlParser.KW_FIRST - 65)) | (1 << (ImpalaSqlParser.KW_FOLLOWING - 65)) | (1 << (ImpalaSqlParser.KW_FORMAT - 65)) | (1 << (ImpalaSqlParser.KW_FUNCTIONS - 65)) | (1 << (ImpalaSqlParser.KW_GRANT - 65)) | (1 << (ImpalaSqlParser.KW_GROUPING - 65)) | (1 << (ImpalaSqlParser.KW_HOUR - 65)) | (1 << (ImpalaSqlParser.KW_IF - 65)) | (1 << (ImpalaSqlParser.KW_INCLUDING - 65)))) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (ImpalaSqlParser.KW_INTERVAL - 101)) | (1 << (ImpalaSqlParser.KW_LAST - 101)) | (1 << (ImpalaSqlParser.KW_LATERAL - 101)) | (1 << (ImpalaSqlParser.KW_LIMIT - 101)) | (1 << (ImpalaSqlParser.KW_LOCALTIME - 101)) | (1 << (ImpalaSqlParser.KW_LOCALTIMESTAMP - 101)) | (1 << (ImpalaSqlParser.KW_MAP - 101)) | (1 << (ImpalaSqlParser.KW_MINUTE - 101)) | (1 << (ImpalaSqlParser.KW_MONTH - 101)) | (1 << (ImpalaSqlParser.KW_NFC - 101)) | (1 << (ImpalaSqlParser.KW_NFD - 101)) | (1 << (ImpalaSqlParser.KW_NFKC - 101)) | (1 << (ImpalaSqlParser.KW_NFKD - 101)) | (1 << (ImpalaSqlParser.KW_NORMALIZE - 101)) | (1 << (ImpalaSqlParser.KW_NOT - 101)) | (1 << (ImpalaSqlParser.KW_NULL - 101)))) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & ((1 << (ImpalaSqlParser.KW_NULLS - 133)) | (1 << (ImpalaSqlParser.KW_OFFSET - 133)) | (1 << (ImpalaSqlParser.KW_OPTION - 133)) | (1 << (ImpalaSqlParser.KW_ORDINALITY - 133)) | (1 << (ImpalaSqlParser.KW_OVER - 133)) | (1 << (ImpalaSqlParser.KW_PARTITION - 133)) | (1 << (ImpalaSqlParser.KW_PARTITIONS - 133)) | (1 << (ImpalaSqlParser.KW_PARQUET - 133)) | (1 << (ImpalaSqlParser.KW_POSITION - 133)) | (1 << (ImpalaSqlParser.KW_PRECEDING - 133)) | (1 << (ImpalaSqlParser.KW_PRIVILEGES - 133)) | (1 << (ImpalaSqlParser.KW_PROPERTIES - 133)) | (1 << (ImpalaSqlParser.KW_RANGE - 133)) | (1 << (ImpalaSqlParser.KW_RENAME - 133)) | (1 << (ImpalaSqlParser.KW_REPEATABLE - 133)) | (1 << (ImpalaSqlParser.KW_REPLACE - 133)) | (1 << (ImpalaSqlParser.KW_RESTRICT - 133)) | (1 << (ImpalaSqlParser.KW_REVOKE - 133)))) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & ((1 << (ImpalaSqlParser.KW_ROLE - 165)) | (1 << (ImpalaSqlParser.KW_ROLES - 165)) | (1 << (ImpalaSqlParser.KW_ROW - 165)) | (1 << (ImpalaSqlParser.KW_ROWS - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMA - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMAS - 165)) | (1 << (ImpalaSqlParser.KW_SECOND - 165)) | (1 << (ImpalaSqlParser.KW_SECONDS - 165)) | (1 << (ImpalaSqlParser.KW_SET - 165)) | (1 << (ImpalaSqlParser.KW_SHOW - 165)) | (1 << (ImpalaSqlParser.KW_SOME - 165)) | (1 << (ImpalaSqlParser.KW_STATS - 165)) | (1 << (ImpalaSqlParser.KW_SUBSTRING - 165)) | (1 << (ImpalaSqlParser.KW_SYSTEM - 165)) | (1 << (ImpalaSqlParser.KW_TABLES - 165)) | (1 << (ImpalaSqlParser.KW_TABLESAMPLE - 165)) | (1 << (ImpalaSqlParser.KW_TO - 165)) | (1 << (ImpalaSqlParser.KW_TRUE - 165)) | (1 << (ImpalaSqlParser.KW_TRY_CAST - 165)) | (1 << (ImpalaSqlParser.KW_TRUNCATE - 165)))) !== 0) || ((((_la - 199)) & ~0x1F) === 0 && ((1 << (_la - 199)) & ((1 << (ImpalaSqlParser.KW_UNBOUNDED - 199)) | (1 << (ImpalaSqlParser.KW_USE - 199)) | (1 << (ImpalaSqlParser.KW_USER - 199)) | (1 << (ImpalaSqlParser.KW_VIEW - 199)) | (1 << (ImpalaSqlParser.KW_VIEWS - 199)) | (1 << (ImpalaSqlParser.KW_YEAR - 199)) | (1 << (ImpalaSqlParser.KW_TEXTFILE - 199)) | (1 << (ImpalaSqlParser.KW_ORC - 199)) | (1 << (ImpalaSqlParser.KW_AVRO - 199)) | (1 << (ImpalaSqlParser.KW_SEQUENCEFILE - 199)) | (1 << (ImpalaSqlParser.KW_RCFILE - 199)))) !== 0) || ((((_la - 236)) & ~0x1F) === 0 && ((1 << (_la - 236)) & ((1 << (ImpalaSqlParser.PLUS - 236)) | (1 << (ImpalaSqlParser.MINUS - 236)) | (1 << (ImpalaSqlParser.LPAREN - 236)) | (1 << (ImpalaSqlParser.QUESTION - 236)) | (1 << (ImpalaSqlParser.STRING - 236)) | (1 << (ImpalaSqlParser.UNICODE_STRING - 236)) | (1 << (ImpalaSqlParser.BINARY_LITERAL - 236)) | (1 << (ImpalaSqlParser.INTEGER_VALUE - 236)) | (1 << (ImpalaSqlParser.DECIMAL_VALUE - 236)) | (1 << (ImpalaSqlParser.DOUBLE_VALUE - 236)) | (1 << (ImpalaSqlParser.IDENTIFIER - 236)) | (1 << (ImpalaSqlParser.DIGIT_IDENTIFIER - 236)) | (1 << (ImpalaSqlParser.BACKQUOTED_IDENTIFIER - 236)) | (1 << (ImpalaSqlParser.DOUBLE_PRECISION - 236)))) !== 0)) { + { + this.state = 1969; + this.columnItem(); + this.state = 1974; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 1970; + this.match(ImpalaSqlParser.COMMA); + this.state = 1971; + this.columnItem(); + } + } + this.state = 1976; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + this.state = 1979; + this.match(ImpalaSqlParser.RPAREN); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 1980; + this.columnItem(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public namedQuery(): NamedQueryContext { + let _localctx: NamedQueryContext = new NamedQueryContext(this._ctx, this.state); + this.enterRule(_localctx, 270, ImpalaSqlParser.RULE_namedQuery); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1983; + _localctx._name = this.identifier(); + this.state = 1985; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.LPAREN) { + { + this.state = 1984; + this.columnAliases(); + } + } + + this.state = 1987; + this.match(ImpalaSqlParser.KW_AS); + this.state = 1988; + this.subQueryRelation(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public setQuantifier(): SetQuantifierContext { + let _localctx: SetQuantifierContext = new SetQuantifierContext(this._ctx, this.state); + this.enterRule(_localctx, 272, ImpalaSqlParser.RULE_setQuantifier); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 1990; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_ALL || _la === ImpalaSqlParser.KW_DISTINCT)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public selectItem(): SelectItemContext { + let _localctx: SelectItemContext = new SelectItemContext(this._ctx, this.state); + this.enterRule(_localctx, 274, ImpalaSqlParser.RULE_selectItem); + let _la: number; + try { + this.state = 2004; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 250, this._ctx) ) { + case 1: + _localctx = new SelectSingleContext(_localctx); + this.enterOuterAlt(_localctx, 1); + { + this.state = 1992; + this.columnItem(); + this.state = 1997; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 249, this._ctx) ) { + case 1: + { + this.state = 1994; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_AS) { + { + this.state = 1993; + this.match(ImpalaSqlParser.KW_AS); + } + } + + this.state = 1996; + this.identifier(); + } + break; + } + } + break; + + case 2: + _localctx = new SelectAllContext(_localctx); + this.enterOuterAlt(_localctx, 2); + { + this.state = 1999; + this.qualifiedName(); + this.state = 2000; + this.match(ImpalaSqlParser.DOT); + this.state = 2001; + this.match(ImpalaSqlParser.ASTERISK); + } + break; + + case 3: + _localctx = new SelectAllContext(_localctx); + this.enterOuterAlt(_localctx, 3); + { + this.state = 2003; + this.match(ImpalaSqlParser.ASTERISK); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + + public relation(): RelationContext; + public relation(_p: number): RelationContext; + // @RuleVersion(0) + public relation(_p?: number): RelationContext { + if (_p === undefined) { + _p = 0; + } + + let _parentctx: ParserRuleContext = this._ctx; + let _parentState: number = this.state; + let _localctx: RelationContext = new RelationContext(this._ctx, _parentState); + let _prevctx: RelationContext = _localctx; + let _startState: number = 276; + this.enterRecursionRule(_localctx, 276, ImpalaSqlParser.RULE_relation, _p); + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + { + _localctx = new RelationDefaultContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + + this.state = 2007; + this.sampledRelation(); + } + this._ctx._stop = this._input.tryLT(-1); + this.state = 2022; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 252, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + if (this._parseListeners != null) { + this.triggerExitRuleEvent(); + } + _prevctx = _localctx; + { + { + _localctx = new JoinRelationContext(new RelationContext(_parentctx, _parentState)); + (_localctx as JoinRelationContext)._left = _prevctx; + this.pushNewRecursionContext(_localctx, _startState, ImpalaSqlParser.RULE_relation); + this.state = 2009; + if (!(this.precpred(this._ctx, 2))) { + throw this.createFailedPredicateException("this.precpred(this._ctx, 2)"); + } + this.state = 2018; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_CROSS: + { + this.state = 2010; + this.match(ImpalaSqlParser.KW_CROSS); + this.state = 2011; + this.match(ImpalaSqlParser.KW_JOIN); + this.state = 2012; + (_localctx as JoinRelationContext)._right = this.sampledRelation(); + } + break; + case ImpalaSqlParser.KW_FULL: + case ImpalaSqlParser.KW_INNER: + case ImpalaSqlParser.KW_JOIN: + case ImpalaSqlParser.KW_LEFT: + case ImpalaSqlParser.KW_RIGHT: + { + this.state = 2013; + this.joinType(); + this.state = 2014; + this.match(ImpalaSqlParser.KW_JOIN); + this.state = 2015; + (_localctx as JoinRelationContext)._rightRelation = this.relation(0); + this.state = 2016; + this.joinCriteria(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + this.state = 2024; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 252, this._ctx); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.unrollRecursionContexts(_parentctx); + } + return _localctx; + } + // @RuleVersion(0) + public joinType(): JoinTypeContext { + let _localctx: JoinTypeContext = new JoinTypeContext(this._ctx, this.state); + this.enterRule(_localctx, 278, ImpalaSqlParser.RULE_joinType); + let _la: number; + try { + this.state = 2056; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 259, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 2026; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_INNER) { + { + this.state = 2025; + this.match(ImpalaSqlParser.KW_INNER); + } + } + + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 2028; + this.match(ImpalaSqlParser.KW_LEFT); + this.state = 2030; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_INNER) { + { + this.state = 2029; + this.match(ImpalaSqlParser.KW_INNER); + } + } + + } + break; + + case 3: + this.enterOuterAlt(_localctx, 3); + { + this.state = 2032; + this.match(ImpalaSqlParser.KW_RIGHT); + this.state = 2034; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_INNER) { + { + this.state = 2033; + this.match(ImpalaSqlParser.KW_INNER); + } + } + + } + break; + + case 4: + this.enterOuterAlt(_localctx, 4); + { + this.state = 2036; + this.match(ImpalaSqlParser.KW_LEFT); + this.state = 2038; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_OUTER) { + { + this.state = 2037; + this.match(ImpalaSqlParser.KW_OUTER); + } + } + + } + break; + + case 5: + this.enterOuterAlt(_localctx, 5); + { + this.state = 2040; + this.match(ImpalaSqlParser.KW_RIGHT); + this.state = 2042; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_OUTER) { + { + this.state = 2041; + this.match(ImpalaSqlParser.KW_OUTER); + } + } + + } + break; + + case 6: + this.enterOuterAlt(_localctx, 6); + { + this.state = 2044; + this.match(ImpalaSqlParser.KW_FULL); + this.state = 2046; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_OUTER) { + { + this.state = 2045; + this.match(ImpalaSqlParser.KW_OUTER); + } + } + + } + break; + + case 7: + this.enterOuterAlt(_localctx, 7); + { + this.state = 2048; + this.match(ImpalaSqlParser.KW_LEFT); + this.state = 2049; + this.match(ImpalaSqlParser.KW_SEMI); + } + break; + + case 8: + this.enterOuterAlt(_localctx, 8); + { + this.state = 2050; + this.match(ImpalaSqlParser.KW_RIGHT); + this.state = 2051; + this.match(ImpalaSqlParser.KW_SEMI); + } + break; + + case 9: + this.enterOuterAlt(_localctx, 9); + { + this.state = 2052; + this.match(ImpalaSqlParser.KW_LEFT); + this.state = 2053; + this.match(ImpalaSqlParser.KW_ANTI); + } + break; + + case 10: + this.enterOuterAlt(_localctx, 10); + { + this.state = 2054; + this.match(ImpalaSqlParser.KW_RIGHT); + this.state = 2055; + this.match(ImpalaSqlParser.KW_ANTI); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public joinCriteria(): JoinCriteriaContext { + let _localctx: JoinCriteriaContext = new JoinCriteriaContext(this._ctx, this.state); + this.enterRule(_localctx, 280, ImpalaSqlParser.RULE_joinCriteria); + let _la: number; + try { + this.state = 2072; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_ON: + this.enterOuterAlt(_localctx, 1); + { + this.state = 2058; + this.match(ImpalaSqlParser.KW_ON); + this.state = 2059; + this.booleanExpression(0); + } + break; + case ImpalaSqlParser.KW_USING: + this.enterOuterAlt(_localctx, 2); + { + this.state = 2060; + this.match(ImpalaSqlParser.KW_USING); + this.state = 2061; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2062; + this.identifier(); + this.state = 2067; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2063; + this.match(ImpalaSqlParser.COMMA); + this.state = 2064; + this.identifier(); + } + } + this.state = 2069; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 2070; + this.match(ImpalaSqlParser.RPAREN); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public sampledRelation(): SampledRelationContext { + let _localctx: SampledRelationContext = new SampledRelationContext(this._ctx, this.state); + this.enterRule(_localctx, 282, ImpalaSqlParser.RULE_sampledRelation); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2074; + this.aliasedRelation(); + this.state = 2087; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 263, this._ctx) ) { + case 1: + { + this.state = 2075; + this.match(ImpalaSqlParser.KW_TABLESAMPLE); + this.state = 2076; + this.sampleType(); + this.state = 2077; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2078; + _localctx._percentage = this.expression(); + this.state = 2079; + this.match(ImpalaSqlParser.RPAREN); + this.state = 2085; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 262, this._ctx) ) { + case 1: + { + this.state = 2080; + this.match(ImpalaSqlParser.KW_REPEATABLE); + this.state = 2081; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2082; + _localctx._seed = this.expression(); + this.state = 2083; + this.match(ImpalaSqlParser.RPAREN); + } + break; + } + } + break; + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public sampleType(): SampleTypeContext { + let _localctx: SampleTypeContext = new SampleTypeContext(this._ctx, this.state); + this.enterRule(_localctx, 284, ImpalaSqlParser.RULE_sampleType); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2089; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_BERNOULLI || _la === ImpalaSqlParser.KW_SYSTEM)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public aliasedRelation(): AliasedRelationContext { + let _localctx: AliasedRelationContext = new AliasedRelationContext(this._ctx, this.state); + this.enterRule(_localctx, 286, ImpalaSqlParser.RULE_aliasedRelation); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2091; + this.relationPrimary(); + this.state = 2099; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 266, this._ctx) ) { + case 1: + { + this.state = 2093; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_AS) { + { + this.state = 2092; + this.match(ImpalaSqlParser.KW_AS); + } + } + + this.state = 2095; + this.identifier(); + this.state = 2097; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 265, this._ctx) ) { + case 1: + { + this.state = 2096; + this.columnAliases(); + } + break; + } + } + break; + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public columnAliases(): ColumnAliasesContext { + let _localctx: ColumnAliasesContext = new ColumnAliasesContext(this._ctx, this.state); + this.enterRule(_localctx, 288, ImpalaSqlParser.RULE_columnAliases); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2101; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2102; + this.columnNamePath(); + this.state = 2107; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2103; + this.match(ImpalaSqlParser.COMMA); + this.state = 2104; + this.columnNamePath(); + } + } + this.state = 2109; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 2110; + this.match(ImpalaSqlParser.RPAREN); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public createColumnAliases(): CreateColumnAliasesContext { + let _localctx: CreateColumnAliasesContext = new CreateColumnAliasesContext(this._ctx, this.state); + this.enterRule(_localctx, 290, ImpalaSqlParser.RULE_createColumnAliases); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2112; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2113; + this.columnNamePath(); + this.state = 2118; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2114; + this.match(ImpalaSqlParser.COMMA); + this.state = 2115; + this.columnNamePath(); + } + } + this.state = 2120; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 2121; + this.match(ImpalaSqlParser.RPAREN); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public relationPrimary(): RelationPrimaryContext { + let _localctx: RelationPrimaryContext = new RelationPrimaryContext(this._ctx, this.state); + this.enterRule(_localctx, 292, ImpalaSqlParser.RULE_relationPrimary); + let _la: number; + try { + this.state = 2130; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 270, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 2123; + this.tableOrViewPath(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 2125; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_LATERAL) { + { + this.state = 2124; + this.match(ImpalaSqlParser.KW_LATERAL); + } + } + + this.state = 2127; + this.subQueryRelation(); + } + break; + + case 3: + this.enterOuterAlt(_localctx, 3); + { + this.state = 2128; + this.unnest(); + } + break; + + case 4: + this.enterOuterAlt(_localctx, 4); + { + this.state = 2129; + this.parenthesizedRelation(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public subQueryRelation(): SubQueryRelationContext { + let _localctx: SubQueryRelationContext = new SubQueryRelationContext(this._ctx, this.state); + this.enterRule(_localctx, 294, ImpalaSqlParser.RULE_subQueryRelation); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2132; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2133; + this.queryStatement(); + this.state = 2134; + this.match(ImpalaSqlParser.RPAREN); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public unnest(): UnnestContext { + let _localctx: UnnestContext = new UnnestContext(this._ctx, this.state); + this.enterRule(_localctx, 296, ImpalaSqlParser.RULE_unnest); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2136; + this.match(ImpalaSqlParser.KW_UNNEST); + this.state = 2137; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2138; + this.expression(); + this.state = 2143; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2139; + this.match(ImpalaSqlParser.COMMA); + this.state = 2140; + this.expression(); + } + } + this.state = 2145; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 2146; + this.match(ImpalaSqlParser.RPAREN); + this.state = 2149; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 272, this._ctx) ) { + case 1: + { + this.state = 2147; + this.match(ImpalaSqlParser.KW_WITH); + this.state = 2148; + this.match(ImpalaSqlParser.KW_ORDINALITY); + } + break; + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public parenthesizedRelation(): ParenthesizedRelationContext { + let _localctx: ParenthesizedRelationContext = new ParenthesizedRelationContext(this._ctx, this.state); + this.enterRule(_localctx, 298, ImpalaSqlParser.RULE_parenthesizedRelation); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2151; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2152; + this.relation(0); + this.state = 2153; + this.match(ImpalaSqlParser.RPAREN); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public columnItem(): ColumnItemContext { + let _localctx: ColumnItemContext = new ColumnItemContext(this._ctx, this.state); + this.enterRule(_localctx, 300, ImpalaSqlParser.RULE_columnItem); + try { + this.state = 2157; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 273, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 2155; + this.columnNamePath(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 2156; + this.expression(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public expression(): ExpressionContext { + let _localctx: ExpressionContext = new ExpressionContext(this._ctx, this.state); + this.enterRule(_localctx, 302, ImpalaSqlParser.RULE_expression); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2159; + this.booleanExpression(0); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + + public booleanExpression(): BooleanExpressionContext; + public booleanExpression(_p: number): BooleanExpressionContext; + // @RuleVersion(0) + public booleanExpression(_p?: number): BooleanExpressionContext { + if (_p === undefined) { + _p = 0; + } + + let _parentctx: ParserRuleContext = this._ctx; + let _parentState: number = this.state; + let _localctx: BooleanExpressionContext = new BooleanExpressionContext(this._ctx, _parentState); + let _prevctx: BooleanExpressionContext = _localctx; + let _startState: number = 304; + this.enterRecursionRule(_localctx, 304, ImpalaSqlParser.RULE_booleanExpression, _p); + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 2168; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_ADD: + case ImpalaSqlParser.KW_ALL: + case ImpalaSqlParser.KW_ANY: + case ImpalaSqlParser.KW_ARRAY: + case ImpalaSqlParser.KW_ASC: + case ImpalaSqlParser.KW_AT: + case ImpalaSqlParser.KW_BERNOULLI: + case ImpalaSqlParser.KW_CASCADE: + case ImpalaSqlParser.KW_CASE: + case ImpalaSqlParser.KW_CAST: + case ImpalaSqlParser.KW_COLUMN: + case ImpalaSqlParser.KW_COLUMNS: + case ImpalaSqlParser.KW_COMMENT: + case ImpalaSqlParser.KW_CURRENT: + case ImpalaSqlParser.KW_CURRENT_DATE: + case ImpalaSqlParser.KW_CURRENT_PATH: + case ImpalaSqlParser.KW_CURRENT_TIME: + case ImpalaSqlParser.KW_CURRENT_TIMESTAMP: + case ImpalaSqlParser.KW_CURRENT_USER: + case ImpalaSqlParser.KW_DATA: + case ImpalaSqlParser.KW_DATABASE: + case ImpalaSqlParser.KW_DATABASES: + case ImpalaSqlParser.KW_DAY: + case ImpalaSqlParser.KW_DAYS: + case ImpalaSqlParser.KW_DEFAULT: + case ImpalaSqlParser.KW_DESC: + case ImpalaSqlParser.KW_EXCLUDING: + case ImpalaSqlParser.KW_EXISTS: + case ImpalaSqlParser.KW_EXPLAIN: + case ImpalaSqlParser.KW_EXTRACT: + case ImpalaSqlParser.KW_FALSE: + case ImpalaSqlParser.KW_FILTER: + case ImpalaSqlParser.KW_FIRST: + case ImpalaSqlParser.KW_FOLLOWING: + case ImpalaSqlParser.KW_FORMAT: + case ImpalaSqlParser.KW_FUNCTIONS: + case ImpalaSqlParser.KW_GRANT: + case ImpalaSqlParser.KW_GROUPING: + case ImpalaSqlParser.KW_HOUR: + case ImpalaSqlParser.KW_IF: + case ImpalaSqlParser.KW_INCLUDING: + case ImpalaSqlParser.KW_INTERVAL: + case ImpalaSqlParser.KW_LAST: + case ImpalaSqlParser.KW_LATERAL: + case ImpalaSqlParser.KW_LIMIT: + case ImpalaSqlParser.KW_LOCALTIME: + case ImpalaSqlParser.KW_LOCALTIMESTAMP: + case ImpalaSqlParser.KW_MAP: + case ImpalaSqlParser.KW_MINUTE: + case ImpalaSqlParser.KW_MONTH: + case ImpalaSqlParser.KW_NFC: + case ImpalaSqlParser.KW_NFD: + case ImpalaSqlParser.KW_NFKC: + case ImpalaSqlParser.KW_NFKD: + case ImpalaSqlParser.KW_NORMALIZE: + case ImpalaSqlParser.KW_NULL: + case ImpalaSqlParser.KW_NULLS: + case ImpalaSqlParser.KW_OFFSET: + case ImpalaSqlParser.KW_OPTION: + case ImpalaSqlParser.KW_ORDINALITY: + case ImpalaSqlParser.KW_OVER: + case ImpalaSqlParser.KW_PARTITION: + case ImpalaSqlParser.KW_PARTITIONS: + case ImpalaSqlParser.KW_PARQUET: + case ImpalaSqlParser.KW_POSITION: + case ImpalaSqlParser.KW_PRECEDING: + case ImpalaSqlParser.KW_PRIVILEGES: + case ImpalaSqlParser.KW_PROPERTIES: + case ImpalaSqlParser.KW_RANGE: + case ImpalaSqlParser.KW_RENAME: + case ImpalaSqlParser.KW_REPEATABLE: + case ImpalaSqlParser.KW_REPLACE: + case ImpalaSqlParser.KW_RESTRICT: + case ImpalaSqlParser.KW_REVOKE: + case ImpalaSqlParser.KW_ROLE: + case ImpalaSqlParser.KW_ROLES: + case ImpalaSqlParser.KW_ROW: + case ImpalaSqlParser.KW_ROWS: + case ImpalaSqlParser.KW_SCHEMA: + case ImpalaSqlParser.KW_SCHEMAS: + case ImpalaSqlParser.KW_SECOND: + case ImpalaSqlParser.KW_SECONDS: + case ImpalaSqlParser.KW_SET: + case ImpalaSqlParser.KW_SHOW: + case ImpalaSqlParser.KW_SOME: + case ImpalaSqlParser.KW_STATS: + case ImpalaSqlParser.KW_SUBSTRING: + case ImpalaSqlParser.KW_SYSTEM: + case ImpalaSqlParser.KW_TABLES: + case ImpalaSqlParser.KW_TABLESAMPLE: + case ImpalaSqlParser.KW_TO: + case ImpalaSqlParser.KW_TRUE: + case ImpalaSqlParser.KW_TRY_CAST: + case ImpalaSqlParser.KW_TRUNCATE: + case ImpalaSqlParser.KW_UNBOUNDED: + case ImpalaSqlParser.KW_USE: + case ImpalaSqlParser.KW_USER: + case ImpalaSqlParser.KW_VIEW: + case ImpalaSqlParser.KW_VIEWS: + case ImpalaSqlParser.KW_YEAR: + case ImpalaSqlParser.KW_TEXTFILE: + case ImpalaSqlParser.KW_ORC: + case ImpalaSqlParser.KW_AVRO: + case ImpalaSqlParser.KW_SEQUENCEFILE: + case ImpalaSqlParser.KW_RCFILE: + case ImpalaSqlParser.PLUS: + case ImpalaSqlParser.MINUS: + case ImpalaSqlParser.LPAREN: + case ImpalaSqlParser.QUESTION: + case ImpalaSqlParser.STRING: + case ImpalaSqlParser.UNICODE_STRING: + case ImpalaSqlParser.BINARY_LITERAL: + case ImpalaSqlParser.INTEGER_VALUE: + case ImpalaSqlParser.DECIMAL_VALUE: + case ImpalaSqlParser.DOUBLE_VALUE: + case ImpalaSqlParser.IDENTIFIER: + case ImpalaSqlParser.DIGIT_IDENTIFIER: + case ImpalaSqlParser.BACKQUOTED_IDENTIFIER: + case ImpalaSqlParser.DOUBLE_PRECISION: + { + _localctx = new PredicatedContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + + this.state = 2162; + (_localctx as PredicatedContext)._valueExpression = this.valueExpression(0); + this.state = 2164; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 274, this._ctx) ) { + case 1: + { + this.state = 2163; + this.predicate((_localctx as PredicatedContext)._valueExpression); + } + break; + } + } + break; + case ImpalaSqlParser.KW_NOT: + { + _localctx = new LogicalNotContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2166; + this.match(ImpalaSqlParser.KW_NOT); + this.state = 2167; + this.booleanExpression(3); + } + break; + default: + throw new NoViableAltException(this); + } + this._ctx._stop = this._input.tryLT(-1); + this.state = 2178; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 277, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + if (this._parseListeners != null) { + this.triggerExitRuleEvent(); + } + _prevctx = _localctx; + { + this.state = 2176; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 276, this._ctx) ) { + case 1: + { + _localctx = new LogicalBinaryContext(new BooleanExpressionContext(_parentctx, _parentState)); + (_localctx as LogicalBinaryContext)._left = _prevctx; + this.pushNewRecursionContext(_localctx, _startState, ImpalaSqlParser.RULE_booleanExpression); + this.state = 2170; + if (!(this.precpred(this._ctx, 2))) { + throw this.createFailedPredicateException("this.precpred(this._ctx, 2)"); + } + this.state = 2171; + (_localctx as LogicalBinaryContext)._operator = this.match(ImpalaSqlParser.KW_AND); + this.state = 2172; + (_localctx as LogicalBinaryContext)._right = this.booleanExpression(3); + } + break; + + case 2: + { + _localctx = new LogicalBinaryContext(new BooleanExpressionContext(_parentctx, _parentState)); + (_localctx as LogicalBinaryContext)._left = _prevctx; + this.pushNewRecursionContext(_localctx, _startState, ImpalaSqlParser.RULE_booleanExpression); + this.state = 2173; + if (!(this.precpred(this._ctx, 1))) { + throw this.createFailedPredicateException("this.precpred(this._ctx, 1)"); + } + this.state = 2174; + (_localctx as LogicalBinaryContext)._operator = this.match(ImpalaSqlParser.KW_OR); + this.state = 2175; + (_localctx as LogicalBinaryContext)._right = this.booleanExpression(2); + } + break; + } + } + } + this.state = 2180; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 277, this._ctx); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.unrollRecursionContexts(_parentctx); + } + return _localctx; + } + // @RuleVersion(0) + public predicate(value: ParserRuleContext): PredicateContext { + let _localctx: PredicateContext = new PredicateContext(this._ctx, this.state, value); + this.enterRule(_localctx, 306, ImpalaSqlParser.RULE_predicate); + let _la: number; + try { + this.state = 2239; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 286, this._ctx) ) { + case 1: + _localctx = new ComparisonContext(_localctx); + this.enterOuterAlt(_localctx, 1); + { + this.state = 2181; + this.comparisonOperator(); + this.state = 2182; + (_localctx as ComparisonContext)._right = this.valueExpression(0); + } + break; + + case 2: + _localctx = new QuantifiedComparisonContext(_localctx); + this.enterOuterAlt(_localctx, 2); + { + this.state = 2184; + this.comparisonOperator(); + this.state = 2185; + this.comparisonQuantifier(); + this.state = 2186; + this.subQueryRelation(); + } + break; + + case 3: + _localctx = new BetweenContext(_localctx); + this.enterOuterAlt(_localctx, 3); + { + this.state = 2189; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_NOT) { + { + this.state = 2188; + this.match(ImpalaSqlParser.KW_NOT); + } + } + + this.state = 2191; + this.match(ImpalaSqlParser.KW_BETWEEN); + this.state = 2192; + (_localctx as BetweenContext)._lower = this.valueExpression(0); + this.state = 2193; + this.match(ImpalaSqlParser.KW_AND); + this.state = 2194; + (_localctx as BetweenContext)._upper = this.valueExpression(0); + } + break; + + case 4: + _localctx = new InListContext(_localctx); + this.enterOuterAlt(_localctx, 4); + { + this.state = 2197; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_NOT) { + { + this.state = 2196; + this.match(ImpalaSqlParser.KW_NOT); + } + } + + this.state = 2199; + this.match(ImpalaSqlParser.KW_IN); + this.state = 2200; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2201; + this.expression(); + this.state = 2206; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2202; + this.match(ImpalaSqlParser.COMMA); + this.state = 2203; + this.expression(); + } + } + this.state = 2208; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 2209; + this.match(ImpalaSqlParser.RPAREN); + } + break; + + case 5: + _localctx = new InSubqueryContext(_localctx); + this.enterOuterAlt(_localctx, 5); + { + this.state = 2212; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_NOT) { + { + this.state = 2211; + this.match(ImpalaSqlParser.KW_NOT); + } + } + + this.state = 2214; + this.match(ImpalaSqlParser.KW_IN); + this.state = 2215; + this.subQueryRelation(); + } + break; + + case 6: + _localctx = new LikeContext(_localctx); + this.enterOuterAlt(_localctx, 6); + { + this.state = 2217; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_NOT) { + { + this.state = 2216; + this.match(ImpalaSqlParser.KW_NOT); + } + } + + this.state = 2219; + this.match(ImpalaSqlParser.KW_LIKE); + this.state = 2220; + (_localctx as LikeContext)._pattern = this.valueExpression(0); + this.state = 2223; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 283, this._ctx) ) { + case 1: + { + this.state = 2221; + this.match(ImpalaSqlParser.KW_ESCAPE); + this.state = 2222; + (_localctx as LikeContext)._escape = this.valueExpression(0); + } + break; + } + } + break; + + case 7: + _localctx = new REGEXPContext(_localctx); + this.enterOuterAlt(_localctx, 7); + { + this.state = 2225; + this.match(ImpalaSqlParser.KW_REGEXP); + this.state = 2226; + (_localctx as REGEXPContext)._pattern = this.valueExpression(0); + } + break; + + case 8: + _localctx = new NullPredicateContext(_localctx); + this.enterOuterAlt(_localctx, 8); + { + this.state = 2227; + this.match(ImpalaSqlParser.KW_IS); + this.state = 2229; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_NOT) { + { + this.state = 2228; + this.match(ImpalaSqlParser.KW_NOT); + } + } + + this.state = 2231; + this.match(ImpalaSqlParser.KW_NULL); + } + break; + + case 9: + _localctx = new DistinctFromContext(_localctx); + this.enterOuterAlt(_localctx, 9); + { + this.state = 2232; + this.match(ImpalaSqlParser.KW_IS); + this.state = 2234; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_NOT) { + { + this.state = 2233; + this.match(ImpalaSqlParser.KW_NOT); + } + } + + this.state = 2236; + this.match(ImpalaSqlParser.KW_DISTINCT); + this.state = 2237; + this.match(ImpalaSqlParser.KW_FROM); + this.state = 2238; + (_localctx as DistinctFromContext)._right = this.valueExpression(0); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + + public valueExpression(): ValueExpressionContext; + public valueExpression(_p: number): ValueExpressionContext; + // @RuleVersion(0) + public valueExpression(_p?: number): ValueExpressionContext { + if (_p === undefined) { + _p = 0; + } + + let _parentctx: ParserRuleContext = this._ctx; + let _parentState: number = this.state; + let _localctx: ValueExpressionContext = new ValueExpressionContext(this._ctx, _parentState); + let _prevctx: ValueExpressionContext = _localctx; + let _startState: number = 308; + this.enterRecursionRule(_localctx, 308, ImpalaSqlParser.RULE_valueExpression, _p); + let _la: number; + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 2245; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 287, this._ctx) ) { + case 1: + { + _localctx = new ValueExpressionDefaultContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + + this.state = 2242; + this.primaryExpression(0); + } + break; + + case 2: + { + _localctx = new ArithmeticUnaryContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2243; + (_localctx as ArithmeticUnaryContext)._operator = this._input.LT(1); + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.PLUS || _la === ImpalaSqlParser.MINUS)) { + (_localctx as ArithmeticUnaryContext)._operator = this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 2244; + this.valueExpression(4); + } + break; + } + this._ctx._stop = this._input.tryLT(-1); + this.state = 2258; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 289, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + if (this._parseListeners != null) { + this.triggerExitRuleEvent(); + } + _prevctx = _localctx; + { + this.state = 2256; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 288, this._ctx) ) { + case 1: + { + _localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState)); + (_localctx as ArithmeticBinaryContext)._left = _prevctx; + this.pushNewRecursionContext(_localctx, _startState, ImpalaSqlParser.RULE_valueExpression); + this.state = 2247; + if (!(this.precpred(this._ctx, 3))) { + throw this.createFailedPredicateException("this.precpred(this._ctx, 3)"); + } + this.state = 2248; + (_localctx as ArithmeticBinaryContext)._operator = this._input.LT(1); + _la = this._input.LA(1); + if (!(((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & ((1 << (ImpalaSqlParser.ASTERISK - 238)) | (1 << (ImpalaSqlParser.SLASH - 238)) | (1 << (ImpalaSqlParser.PERCENT - 238)))) !== 0))) { + (_localctx as ArithmeticBinaryContext)._operator = this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 2249; + (_localctx as ArithmeticBinaryContext)._right = this.valueExpression(4); + } + break; + + case 2: + { + _localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState)); + (_localctx as ArithmeticBinaryContext)._left = _prevctx; + this.pushNewRecursionContext(_localctx, _startState, ImpalaSqlParser.RULE_valueExpression); + this.state = 2250; + if (!(this.precpred(this._ctx, 2))) { + throw this.createFailedPredicateException("this.precpred(this._ctx, 2)"); + } + this.state = 2251; + (_localctx as ArithmeticBinaryContext)._operator = this._input.LT(1); + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.PLUS || _la === ImpalaSqlParser.MINUS)) { + (_localctx as ArithmeticBinaryContext)._operator = this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 2252; + (_localctx as ArithmeticBinaryContext)._right = this.valueExpression(3); + } + break; + + case 3: + { + _localctx = new ConcatenationContext(new ValueExpressionContext(_parentctx, _parentState)); + (_localctx as ConcatenationContext)._left = _prevctx; + this.pushNewRecursionContext(_localctx, _startState, ImpalaSqlParser.RULE_valueExpression); + this.state = 2253; + if (!(this.precpred(this._ctx, 1))) { + throw this.createFailedPredicateException("this.precpred(this._ctx, 1)"); + } + this.state = 2254; + this.match(ImpalaSqlParser.CONCAT); + this.state = 2255; + (_localctx as ConcatenationContext)._right = this.valueExpression(2); + } + break; + } + } + } + this.state = 2260; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 289, this._ctx); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public primaryExpression(): PrimaryExpressionContext; + public primaryExpression(_p: number): PrimaryExpressionContext; + // @RuleVersion(0) + public primaryExpression(_p?: number): PrimaryExpressionContext { + if (_p === undefined) { + _p = 0; + } + + let _parentctx: ParserRuleContext = this._ctx; + let _parentState: number = this.state; + let _localctx: PrimaryExpressionContext = new PrimaryExpressionContext(this._ctx, _parentState); + let _prevctx: PrimaryExpressionContext = _localctx; + let _startState: number = 310; + this.enterRecursionRule(_localctx, 310, ImpalaSqlParser.RULE_primaryExpression, _p); + let _la: number; + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 2507; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 319, this._ctx) ) { + case 1: + { + _localctx = new NullLiteralContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + + this.state = 2262; + this.match(ImpalaSqlParser.KW_NULL); + } + break; + + case 2: + { + _localctx = new IntervalLiteralContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2263; + this.interval(); + } + break; + + case 3: + { + _localctx = new TypeConstructorContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2264; + this.identifier(); + this.state = 2265; + this.stringLiteral(); + } + break; + + case 4: + { + _localctx = new TypeConstructorContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2267; + this.match(ImpalaSqlParser.DOUBLE_PRECISION); + this.state = 2268; + this.stringLiteral(); + } + break; + + case 5: + { + _localctx = new NumericLiteralContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2269; + this.number(); + } + break; + + case 6: + { + _localctx = new BooleanLiteralContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2270; + this.booleanValue(); + } + break; + + case 7: + { + _localctx = new StringLiteralValuesContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2271; + this.stringLiteral(); + } + break; + + case 8: + { + _localctx = new BinaryLiteralContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2272; + this.match(ImpalaSqlParser.BINARY_LITERAL); + } + break; + + case 9: + { + _localctx = new ParameterContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2273; + this.match(ImpalaSqlParser.QUESTION); + } + break; + + case 10: + { + _localctx = new PositionContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2274; + this.match(ImpalaSqlParser.KW_POSITION); + this.state = 2275; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2276; + this.valueExpression(0); + this.state = 2277; + this.match(ImpalaSqlParser.KW_IN); + this.state = 2278; + this.valueExpression(0); + this.state = 2279; + this.match(ImpalaSqlParser.RPAREN); + } + break; + + case 11: + { + _localctx = new RowConstructorContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2281; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2282; + this.expression(); + this.state = 2285; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_AS) { + { + this.state = 2283; + this.match(ImpalaSqlParser.KW_AS); + this.state = 2284; + this.type(0); + } + } + + this.state = 2295; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 292, this._ctx); + while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1 + 1) { + { + { + this.state = 2287; + this.match(ImpalaSqlParser.COMMA); + this.state = 2288; + this.expression(); + this.state = 2291; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_AS) { + { + this.state = 2289; + this.match(ImpalaSqlParser.KW_AS); + this.state = 2290; + this.type(0); + } + } + + } + } + } + this.state = 2297; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 292, this._ctx); + } + this.state = 2298; + this.match(ImpalaSqlParser.RPAREN); + } + break; + + case 12: + { + _localctx = new RowConstructorContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2300; + this.match(ImpalaSqlParser.KW_ROW); + this.state = 2301; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2302; + this.expression(); + this.state = 2307; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2303; + this.match(ImpalaSqlParser.COMMA); + this.state = 2304; + this.expression(); + } + } + this.state = 2309; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 2310; + this.match(ImpalaSqlParser.RPAREN); + } + break; + + case 13: + { + _localctx = new FunctionCallContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2312; + this.functionNamePath(); + this.state = 2313; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2314; + this.match(ImpalaSqlParser.ASTERISK); + this.state = 2315; + this.match(ImpalaSqlParser.RPAREN); + this.state = 2317; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 294, this._ctx) ) { + case 1: + { + this.state = 2316; + this.filter(); + } + break; + } + this.state = 2320; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 295, this._ctx) ) { + case 1: + { + this.state = 2319; + this.over(); + } + break; + } + } + break; + + case 14: + { + _localctx = new FunctionCallContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2322; + this.functionNamePath(); + this.state = 2323; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2335; + this._errHandler.sync(this); + _la = this._input.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ImpalaSqlParser.KW_ADD) | (1 << ImpalaSqlParser.KW_ALL) | (1 << ImpalaSqlParser.KW_ANY) | (1 << ImpalaSqlParser.KW_ARRAY) | (1 << ImpalaSqlParser.KW_ASC) | (1 << ImpalaSqlParser.KW_AT) | (1 << ImpalaSqlParser.KW_BERNOULLI) | (1 << ImpalaSqlParser.KW_CASCADE) | (1 << ImpalaSqlParser.KW_CASE) | (1 << ImpalaSqlParser.KW_CAST))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (ImpalaSqlParser.KW_COLUMN - 32)) | (1 << (ImpalaSqlParser.KW_COLUMNS - 32)) | (1 << (ImpalaSqlParser.KW_COMMENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_DATE - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_PATH - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_TIME - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_TIMESTAMP - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_USER - 32)) | (1 << (ImpalaSqlParser.KW_DATA - 32)) | (1 << (ImpalaSqlParser.KW_DATABASE - 32)) | (1 << (ImpalaSqlParser.KW_DATABASES - 32)) | (1 << (ImpalaSqlParser.KW_DAY - 32)) | (1 << (ImpalaSqlParser.KW_DAYS - 32)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 32)) | (1 << (ImpalaSqlParser.KW_DESC - 32)) | (1 << (ImpalaSqlParser.KW_DISTINCT - 32)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (ImpalaSqlParser.KW_EXCLUDING - 65)) | (1 << (ImpalaSqlParser.KW_EXISTS - 65)) | (1 << (ImpalaSqlParser.KW_EXPLAIN - 65)) | (1 << (ImpalaSqlParser.KW_EXTRACT - 65)) | (1 << (ImpalaSqlParser.KW_FALSE - 65)) | (1 << (ImpalaSqlParser.KW_FILTER - 65)) | (1 << (ImpalaSqlParser.KW_FIRST - 65)) | (1 << (ImpalaSqlParser.KW_FOLLOWING - 65)) | (1 << (ImpalaSqlParser.KW_FORMAT - 65)) | (1 << (ImpalaSqlParser.KW_FUNCTIONS - 65)) | (1 << (ImpalaSqlParser.KW_GRANT - 65)) | (1 << (ImpalaSqlParser.KW_GROUPING - 65)) | (1 << (ImpalaSqlParser.KW_HOUR - 65)) | (1 << (ImpalaSqlParser.KW_IF - 65)) | (1 << (ImpalaSqlParser.KW_INCLUDING - 65)))) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (ImpalaSqlParser.KW_INTERVAL - 101)) | (1 << (ImpalaSqlParser.KW_LAST - 101)) | (1 << (ImpalaSqlParser.KW_LATERAL - 101)) | (1 << (ImpalaSqlParser.KW_LIMIT - 101)) | (1 << (ImpalaSqlParser.KW_LOCALTIME - 101)) | (1 << (ImpalaSqlParser.KW_LOCALTIMESTAMP - 101)) | (1 << (ImpalaSqlParser.KW_MAP - 101)) | (1 << (ImpalaSqlParser.KW_MINUTE - 101)) | (1 << (ImpalaSqlParser.KW_MONTH - 101)) | (1 << (ImpalaSqlParser.KW_NFC - 101)) | (1 << (ImpalaSqlParser.KW_NFD - 101)) | (1 << (ImpalaSqlParser.KW_NFKC - 101)) | (1 << (ImpalaSqlParser.KW_NFKD - 101)) | (1 << (ImpalaSqlParser.KW_NORMALIZE - 101)) | (1 << (ImpalaSqlParser.KW_NOT - 101)) | (1 << (ImpalaSqlParser.KW_NULL - 101)))) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & ((1 << (ImpalaSqlParser.KW_NULLS - 133)) | (1 << (ImpalaSqlParser.KW_OFFSET - 133)) | (1 << (ImpalaSqlParser.KW_OPTION - 133)) | (1 << (ImpalaSqlParser.KW_ORDINALITY - 133)) | (1 << (ImpalaSqlParser.KW_OVER - 133)) | (1 << (ImpalaSqlParser.KW_PARTITION - 133)) | (1 << (ImpalaSqlParser.KW_PARTITIONS - 133)) | (1 << (ImpalaSqlParser.KW_PARQUET - 133)) | (1 << (ImpalaSqlParser.KW_POSITION - 133)) | (1 << (ImpalaSqlParser.KW_PRECEDING - 133)) | (1 << (ImpalaSqlParser.KW_PRIVILEGES - 133)) | (1 << (ImpalaSqlParser.KW_PROPERTIES - 133)) | (1 << (ImpalaSqlParser.KW_RANGE - 133)) | (1 << (ImpalaSqlParser.KW_RENAME - 133)) | (1 << (ImpalaSqlParser.KW_REPEATABLE - 133)) | (1 << (ImpalaSqlParser.KW_REPLACE - 133)) | (1 << (ImpalaSqlParser.KW_RESTRICT - 133)) | (1 << (ImpalaSqlParser.KW_REVOKE - 133)))) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & ((1 << (ImpalaSqlParser.KW_ROLE - 165)) | (1 << (ImpalaSqlParser.KW_ROLES - 165)) | (1 << (ImpalaSqlParser.KW_ROW - 165)) | (1 << (ImpalaSqlParser.KW_ROWS - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMA - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMAS - 165)) | (1 << (ImpalaSqlParser.KW_SECOND - 165)) | (1 << (ImpalaSqlParser.KW_SECONDS - 165)) | (1 << (ImpalaSqlParser.KW_SET - 165)) | (1 << (ImpalaSqlParser.KW_SHOW - 165)) | (1 << (ImpalaSqlParser.KW_SOME - 165)) | (1 << (ImpalaSqlParser.KW_STATS - 165)) | (1 << (ImpalaSqlParser.KW_SUBSTRING - 165)) | (1 << (ImpalaSqlParser.KW_SYSTEM - 165)) | (1 << (ImpalaSqlParser.KW_TABLES - 165)) | (1 << (ImpalaSqlParser.KW_TABLESAMPLE - 165)) | (1 << (ImpalaSqlParser.KW_TO - 165)) | (1 << (ImpalaSqlParser.KW_TRUE - 165)) | (1 << (ImpalaSqlParser.KW_TRY_CAST - 165)) | (1 << (ImpalaSqlParser.KW_TRUNCATE - 165)))) !== 0) || ((((_la - 199)) & ~0x1F) === 0 && ((1 << (_la - 199)) & ((1 << (ImpalaSqlParser.KW_UNBOUNDED - 199)) | (1 << (ImpalaSqlParser.KW_USE - 199)) | (1 << (ImpalaSqlParser.KW_USER - 199)) | (1 << (ImpalaSqlParser.KW_VIEW - 199)) | (1 << (ImpalaSqlParser.KW_VIEWS - 199)) | (1 << (ImpalaSqlParser.KW_YEAR - 199)) | (1 << (ImpalaSqlParser.KW_TEXTFILE - 199)) | (1 << (ImpalaSqlParser.KW_ORC - 199)) | (1 << (ImpalaSqlParser.KW_AVRO - 199)) | (1 << (ImpalaSqlParser.KW_SEQUENCEFILE - 199)) | (1 << (ImpalaSqlParser.KW_RCFILE - 199)))) !== 0) || ((((_la - 236)) & ~0x1F) === 0 && ((1 << (_la - 236)) & ((1 << (ImpalaSqlParser.PLUS - 236)) | (1 << (ImpalaSqlParser.MINUS - 236)) | (1 << (ImpalaSqlParser.LPAREN - 236)) | (1 << (ImpalaSqlParser.QUESTION - 236)) | (1 << (ImpalaSqlParser.STRING - 236)) | (1 << (ImpalaSqlParser.UNICODE_STRING - 236)) | (1 << (ImpalaSqlParser.BINARY_LITERAL - 236)) | (1 << (ImpalaSqlParser.INTEGER_VALUE - 236)) | (1 << (ImpalaSqlParser.DECIMAL_VALUE - 236)) | (1 << (ImpalaSqlParser.DOUBLE_VALUE - 236)) | (1 << (ImpalaSqlParser.IDENTIFIER - 236)) | (1 << (ImpalaSqlParser.DIGIT_IDENTIFIER - 236)) | (1 << (ImpalaSqlParser.BACKQUOTED_IDENTIFIER - 236)) | (1 << (ImpalaSqlParser.DOUBLE_PRECISION - 236)))) !== 0)) { + { + this.state = 2325; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 296, this._ctx) ) { + case 1: + { + this.state = 2324; + this.setQuantifier(); + } + break; + } + this.state = 2327; + this.expression(); + this.state = 2332; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2328; + this.match(ImpalaSqlParser.COMMA); + this.state = 2329; + this.expression(); + } + } + this.state = 2334; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + this.state = 2347; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ORDER) { + { + this.state = 2337; + this.match(ImpalaSqlParser.KW_ORDER); + this.state = 2338; + this.match(ImpalaSqlParser.KW_BY); + this.state = 2339; + this.sortItem(); + this.state = 2344; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2340; + this.match(ImpalaSqlParser.COMMA); + this.state = 2341; + this.sortItem(); + } + } + this.state = 2346; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + this.state = 2349; + this.match(ImpalaSqlParser.RPAREN); + this.state = 2351; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 301, this._ctx) ) { + case 1: + { + this.state = 2350; + this.filter(); + } + break; + } + this.state = 2354; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 302, this._ctx) ) { + case 1: + { + this.state = 2353; + this.over(); + } + break; + } + } + break; + + case 15: + { + _localctx = new LambdaContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2356; + this.identifier(); + this.state = 2357; + this.match(ImpalaSqlParser.RIGHT_ARROW); + this.state = 2358; + this.expression(); + } + break; + + case 16: + { + _localctx = new LambdaContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2360; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2369; + this._errHandler.sync(this); + _la = this._input.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ImpalaSqlParser.KW_ADD) | (1 << ImpalaSqlParser.KW_ALL) | (1 << ImpalaSqlParser.KW_ANY) | (1 << ImpalaSqlParser.KW_ARRAY) | (1 << ImpalaSqlParser.KW_ASC) | (1 << ImpalaSqlParser.KW_AT) | (1 << ImpalaSqlParser.KW_BERNOULLI) | (1 << ImpalaSqlParser.KW_CASCADE))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (ImpalaSqlParser.KW_COLUMN - 32)) | (1 << (ImpalaSqlParser.KW_COLUMNS - 32)) | (1 << (ImpalaSqlParser.KW_COMMENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT - 32)) | (1 << (ImpalaSqlParser.KW_DATA - 32)) | (1 << (ImpalaSqlParser.KW_DATABASE - 32)) | (1 << (ImpalaSqlParser.KW_DATABASES - 32)) | (1 << (ImpalaSqlParser.KW_DAY - 32)) | (1 << (ImpalaSqlParser.KW_DAYS - 32)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 32)) | (1 << (ImpalaSqlParser.KW_DESC - 32)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (ImpalaSqlParser.KW_EXCLUDING - 65)) | (1 << (ImpalaSqlParser.KW_EXPLAIN - 65)) | (1 << (ImpalaSqlParser.KW_FILTER - 65)) | (1 << (ImpalaSqlParser.KW_FIRST - 65)) | (1 << (ImpalaSqlParser.KW_FOLLOWING - 65)) | (1 << (ImpalaSqlParser.KW_FORMAT - 65)) | (1 << (ImpalaSqlParser.KW_FUNCTIONS - 65)) | (1 << (ImpalaSqlParser.KW_GRANT - 65)) | (1 << (ImpalaSqlParser.KW_HOUR - 65)) | (1 << (ImpalaSqlParser.KW_IF - 65)) | (1 << (ImpalaSqlParser.KW_INCLUDING - 65)))) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (ImpalaSqlParser.KW_INTERVAL - 101)) | (1 << (ImpalaSqlParser.KW_LAST - 101)) | (1 << (ImpalaSqlParser.KW_LATERAL - 101)) | (1 << (ImpalaSqlParser.KW_LIMIT - 101)) | (1 << (ImpalaSqlParser.KW_MAP - 101)) | (1 << (ImpalaSqlParser.KW_MINUTE - 101)) | (1 << (ImpalaSqlParser.KW_MONTH - 101)) | (1 << (ImpalaSqlParser.KW_NFC - 101)) | (1 << (ImpalaSqlParser.KW_NFD - 101)) | (1 << (ImpalaSqlParser.KW_NFKC - 101)) | (1 << (ImpalaSqlParser.KW_NFKD - 101)))) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & ((1 << (ImpalaSqlParser.KW_NULLS - 133)) | (1 << (ImpalaSqlParser.KW_OFFSET - 133)) | (1 << (ImpalaSqlParser.KW_OPTION - 133)) | (1 << (ImpalaSqlParser.KW_ORDINALITY - 133)) | (1 << (ImpalaSqlParser.KW_OVER - 133)) | (1 << (ImpalaSqlParser.KW_PARTITION - 133)) | (1 << (ImpalaSqlParser.KW_PARTITIONS - 133)) | (1 << (ImpalaSqlParser.KW_PARQUET - 133)) | (1 << (ImpalaSqlParser.KW_POSITION - 133)) | (1 << (ImpalaSqlParser.KW_PRECEDING - 133)) | (1 << (ImpalaSqlParser.KW_PRIVILEGES - 133)) | (1 << (ImpalaSqlParser.KW_PROPERTIES - 133)) | (1 << (ImpalaSqlParser.KW_RANGE - 133)) | (1 << (ImpalaSqlParser.KW_RENAME - 133)) | (1 << (ImpalaSqlParser.KW_REPEATABLE - 133)) | (1 << (ImpalaSqlParser.KW_REPLACE - 133)) | (1 << (ImpalaSqlParser.KW_RESTRICT - 133)) | (1 << (ImpalaSqlParser.KW_REVOKE - 133)))) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & ((1 << (ImpalaSqlParser.KW_ROLE - 165)) | (1 << (ImpalaSqlParser.KW_ROLES - 165)) | (1 << (ImpalaSqlParser.KW_ROW - 165)) | (1 << (ImpalaSqlParser.KW_ROWS - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMA - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMAS - 165)) | (1 << (ImpalaSqlParser.KW_SECOND - 165)) | (1 << (ImpalaSqlParser.KW_SECONDS - 165)) | (1 << (ImpalaSqlParser.KW_SET - 165)) | (1 << (ImpalaSqlParser.KW_SHOW - 165)) | (1 << (ImpalaSqlParser.KW_SOME - 165)) | (1 << (ImpalaSqlParser.KW_STATS - 165)) | (1 << (ImpalaSqlParser.KW_SUBSTRING - 165)) | (1 << (ImpalaSqlParser.KW_SYSTEM - 165)) | (1 << (ImpalaSqlParser.KW_TABLES - 165)) | (1 << (ImpalaSqlParser.KW_TABLESAMPLE - 165)) | (1 << (ImpalaSqlParser.KW_TO - 165)) | (1 << (ImpalaSqlParser.KW_TRY_CAST - 165)) | (1 << (ImpalaSqlParser.KW_TRUNCATE - 165)))) !== 0) || ((((_la - 199)) & ~0x1F) === 0 && ((1 << (_la - 199)) & ((1 << (ImpalaSqlParser.KW_UNBOUNDED - 199)) | (1 << (ImpalaSqlParser.KW_USE - 199)) | (1 << (ImpalaSqlParser.KW_USER - 199)) | (1 << (ImpalaSqlParser.KW_VIEW - 199)) | (1 << (ImpalaSqlParser.KW_VIEWS - 199)) | (1 << (ImpalaSqlParser.KW_YEAR - 199)) | (1 << (ImpalaSqlParser.KW_TEXTFILE - 199)) | (1 << (ImpalaSqlParser.KW_ORC - 199)) | (1 << (ImpalaSqlParser.KW_AVRO - 199)) | (1 << (ImpalaSqlParser.KW_SEQUENCEFILE - 199)) | (1 << (ImpalaSqlParser.KW_RCFILE - 199)))) !== 0) || ((((_la - 255)) & ~0x1F) === 0 && ((1 << (_la - 255)) & ((1 << (ImpalaSqlParser.STRING - 255)) | (1 << (ImpalaSqlParser.IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.DIGIT_IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.BACKQUOTED_IDENTIFIER - 255)))) !== 0)) { + { + this.state = 2361; + this.identifier(); + this.state = 2366; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2362; + this.match(ImpalaSqlParser.COMMA); + this.state = 2363; + this.identifier(); + } + } + this.state = 2368; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + this.state = 2371; + this.match(ImpalaSqlParser.RPAREN); + this.state = 2372; + this.match(ImpalaSqlParser.RIGHT_ARROW); + this.state = 2373; + this.expression(); + } + break; + + case 17: + { + _localctx = new SubqueryExpressionContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2374; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2375; + this.queryStatement(); + this.state = 2376; + this.match(ImpalaSqlParser.RPAREN); + } + break; + + case 18: + { + _localctx = new ExistsContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2378; + this.match(ImpalaSqlParser.KW_EXISTS); + this.state = 2379; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2380; + this.queryStatement(); + this.state = 2381; + this.match(ImpalaSqlParser.RPAREN); + } + break; + + case 19: + { + _localctx = new SimpleCaseContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2383; + this.match(ImpalaSqlParser.KW_CASE); + this.state = 2384; + this.valueExpression(0); + this.state = 2386; + this._errHandler.sync(this); + _la = this._input.LA(1); + do { + { + { + this.state = 2385; + this.whenClause(); + } + } + this.state = 2388; + this._errHandler.sync(this); + _la = this._input.LA(1); + } while (_la === ImpalaSqlParser.KW_WHEN); + this.state = 2392; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ELSE) { + { + this.state = 2390; + this.match(ImpalaSqlParser.KW_ELSE); + this.state = 2391; + (_localctx as SimpleCaseContext)._elseExpression = this.expression(); + } + } + + this.state = 2394; + this.match(ImpalaSqlParser.KW_END); + } + break; + + case 20: + { + _localctx = new SearchedCaseContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2396; + this.match(ImpalaSqlParser.KW_CASE); + this.state = 2398; + this._errHandler.sync(this); + _la = this._input.LA(1); + do { + { + { + this.state = 2397; + this.whenClause(); + } + } + this.state = 2400; + this._errHandler.sync(this); + _la = this._input.LA(1); + } while (_la === ImpalaSqlParser.KW_WHEN); + this.state = 2404; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ELSE) { + { + this.state = 2402; + this.match(ImpalaSqlParser.KW_ELSE); + this.state = 2403; + (_localctx as SearchedCaseContext)._elseExpression = this.expression(); + } + } + + this.state = 2406; + this.match(ImpalaSqlParser.KW_END); + } + break; + + case 21: + { + _localctx = new CastContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2408; + this.match(ImpalaSqlParser.KW_CAST); + this.state = 2409; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2410; + this.expression(); + this.state = 2411; + this.match(ImpalaSqlParser.KW_AS); + this.state = 2412; + this.type(0); + this.state = 2413; + this.match(ImpalaSqlParser.RPAREN); + } + break; + + case 22: + { + _localctx = new CastContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2415; + this.match(ImpalaSqlParser.KW_TRY_CAST); + this.state = 2416; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2417; + this.expression(); + this.state = 2418; + this.match(ImpalaSqlParser.KW_AS); + this.state = 2419; + this.type(0); + this.state = 2420; + this.match(ImpalaSqlParser.RPAREN); + } + break; + + case 23: + { + _localctx = new ArrayConstructorContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2422; + this.match(ImpalaSqlParser.KW_ARRAY); + this.state = 2423; + this.match(ImpalaSqlParser.LSQUARE); + this.state = 2432; + this._errHandler.sync(this); + _la = this._input.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ImpalaSqlParser.KW_ADD) | (1 << ImpalaSqlParser.KW_ALL) | (1 << ImpalaSqlParser.KW_ANY) | (1 << ImpalaSqlParser.KW_ARRAY) | (1 << ImpalaSqlParser.KW_ASC) | (1 << ImpalaSqlParser.KW_AT) | (1 << ImpalaSqlParser.KW_BERNOULLI) | (1 << ImpalaSqlParser.KW_CASCADE) | (1 << ImpalaSqlParser.KW_CASE) | (1 << ImpalaSqlParser.KW_CAST))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (ImpalaSqlParser.KW_COLUMN - 32)) | (1 << (ImpalaSqlParser.KW_COLUMNS - 32)) | (1 << (ImpalaSqlParser.KW_COMMENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_DATE - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_PATH - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_TIME - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_TIMESTAMP - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT_USER - 32)) | (1 << (ImpalaSqlParser.KW_DATA - 32)) | (1 << (ImpalaSqlParser.KW_DATABASE - 32)) | (1 << (ImpalaSqlParser.KW_DATABASES - 32)) | (1 << (ImpalaSqlParser.KW_DAY - 32)) | (1 << (ImpalaSqlParser.KW_DAYS - 32)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 32)) | (1 << (ImpalaSqlParser.KW_DESC - 32)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (ImpalaSqlParser.KW_EXCLUDING - 65)) | (1 << (ImpalaSqlParser.KW_EXISTS - 65)) | (1 << (ImpalaSqlParser.KW_EXPLAIN - 65)) | (1 << (ImpalaSqlParser.KW_EXTRACT - 65)) | (1 << (ImpalaSqlParser.KW_FALSE - 65)) | (1 << (ImpalaSqlParser.KW_FILTER - 65)) | (1 << (ImpalaSqlParser.KW_FIRST - 65)) | (1 << (ImpalaSqlParser.KW_FOLLOWING - 65)) | (1 << (ImpalaSqlParser.KW_FORMAT - 65)) | (1 << (ImpalaSqlParser.KW_FUNCTIONS - 65)) | (1 << (ImpalaSqlParser.KW_GRANT - 65)) | (1 << (ImpalaSqlParser.KW_GROUPING - 65)) | (1 << (ImpalaSqlParser.KW_HOUR - 65)) | (1 << (ImpalaSqlParser.KW_IF - 65)) | (1 << (ImpalaSqlParser.KW_INCLUDING - 65)))) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (ImpalaSqlParser.KW_INTERVAL - 101)) | (1 << (ImpalaSqlParser.KW_LAST - 101)) | (1 << (ImpalaSqlParser.KW_LATERAL - 101)) | (1 << (ImpalaSqlParser.KW_LIMIT - 101)) | (1 << (ImpalaSqlParser.KW_LOCALTIME - 101)) | (1 << (ImpalaSqlParser.KW_LOCALTIMESTAMP - 101)) | (1 << (ImpalaSqlParser.KW_MAP - 101)) | (1 << (ImpalaSqlParser.KW_MINUTE - 101)) | (1 << (ImpalaSqlParser.KW_MONTH - 101)) | (1 << (ImpalaSqlParser.KW_NFC - 101)) | (1 << (ImpalaSqlParser.KW_NFD - 101)) | (1 << (ImpalaSqlParser.KW_NFKC - 101)) | (1 << (ImpalaSqlParser.KW_NFKD - 101)) | (1 << (ImpalaSqlParser.KW_NORMALIZE - 101)) | (1 << (ImpalaSqlParser.KW_NOT - 101)) | (1 << (ImpalaSqlParser.KW_NULL - 101)))) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & ((1 << (ImpalaSqlParser.KW_NULLS - 133)) | (1 << (ImpalaSqlParser.KW_OFFSET - 133)) | (1 << (ImpalaSqlParser.KW_OPTION - 133)) | (1 << (ImpalaSqlParser.KW_ORDINALITY - 133)) | (1 << (ImpalaSqlParser.KW_OVER - 133)) | (1 << (ImpalaSqlParser.KW_PARTITION - 133)) | (1 << (ImpalaSqlParser.KW_PARTITIONS - 133)) | (1 << (ImpalaSqlParser.KW_PARQUET - 133)) | (1 << (ImpalaSqlParser.KW_POSITION - 133)) | (1 << (ImpalaSqlParser.KW_PRECEDING - 133)) | (1 << (ImpalaSqlParser.KW_PRIVILEGES - 133)) | (1 << (ImpalaSqlParser.KW_PROPERTIES - 133)) | (1 << (ImpalaSqlParser.KW_RANGE - 133)) | (1 << (ImpalaSqlParser.KW_RENAME - 133)) | (1 << (ImpalaSqlParser.KW_REPEATABLE - 133)) | (1 << (ImpalaSqlParser.KW_REPLACE - 133)) | (1 << (ImpalaSqlParser.KW_RESTRICT - 133)) | (1 << (ImpalaSqlParser.KW_REVOKE - 133)))) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & ((1 << (ImpalaSqlParser.KW_ROLE - 165)) | (1 << (ImpalaSqlParser.KW_ROLES - 165)) | (1 << (ImpalaSqlParser.KW_ROW - 165)) | (1 << (ImpalaSqlParser.KW_ROWS - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMA - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMAS - 165)) | (1 << (ImpalaSqlParser.KW_SECOND - 165)) | (1 << (ImpalaSqlParser.KW_SECONDS - 165)) | (1 << (ImpalaSqlParser.KW_SET - 165)) | (1 << (ImpalaSqlParser.KW_SHOW - 165)) | (1 << (ImpalaSqlParser.KW_SOME - 165)) | (1 << (ImpalaSqlParser.KW_STATS - 165)) | (1 << (ImpalaSqlParser.KW_SUBSTRING - 165)) | (1 << (ImpalaSqlParser.KW_SYSTEM - 165)) | (1 << (ImpalaSqlParser.KW_TABLES - 165)) | (1 << (ImpalaSqlParser.KW_TABLESAMPLE - 165)) | (1 << (ImpalaSqlParser.KW_TO - 165)) | (1 << (ImpalaSqlParser.KW_TRUE - 165)) | (1 << (ImpalaSqlParser.KW_TRY_CAST - 165)) | (1 << (ImpalaSqlParser.KW_TRUNCATE - 165)))) !== 0) || ((((_la - 199)) & ~0x1F) === 0 && ((1 << (_la - 199)) & ((1 << (ImpalaSqlParser.KW_UNBOUNDED - 199)) | (1 << (ImpalaSqlParser.KW_USE - 199)) | (1 << (ImpalaSqlParser.KW_USER - 199)) | (1 << (ImpalaSqlParser.KW_VIEW - 199)) | (1 << (ImpalaSqlParser.KW_VIEWS - 199)) | (1 << (ImpalaSqlParser.KW_YEAR - 199)) | (1 << (ImpalaSqlParser.KW_TEXTFILE - 199)) | (1 << (ImpalaSqlParser.KW_ORC - 199)) | (1 << (ImpalaSqlParser.KW_AVRO - 199)) | (1 << (ImpalaSqlParser.KW_SEQUENCEFILE - 199)) | (1 << (ImpalaSqlParser.KW_RCFILE - 199)))) !== 0) || ((((_la - 236)) & ~0x1F) === 0 && ((1 << (_la - 236)) & ((1 << (ImpalaSqlParser.PLUS - 236)) | (1 << (ImpalaSqlParser.MINUS - 236)) | (1 << (ImpalaSqlParser.LPAREN - 236)) | (1 << (ImpalaSqlParser.QUESTION - 236)) | (1 << (ImpalaSqlParser.STRING - 236)) | (1 << (ImpalaSqlParser.UNICODE_STRING - 236)) | (1 << (ImpalaSqlParser.BINARY_LITERAL - 236)) | (1 << (ImpalaSqlParser.INTEGER_VALUE - 236)) | (1 << (ImpalaSqlParser.DECIMAL_VALUE - 236)) | (1 << (ImpalaSqlParser.DOUBLE_VALUE - 236)) | (1 << (ImpalaSqlParser.IDENTIFIER - 236)) | (1 << (ImpalaSqlParser.DIGIT_IDENTIFIER - 236)) | (1 << (ImpalaSqlParser.BACKQUOTED_IDENTIFIER - 236)) | (1 << (ImpalaSqlParser.DOUBLE_PRECISION - 236)))) !== 0)) { + { + this.state = 2424; + this.expression(); + this.state = 2429; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2425; + this.match(ImpalaSqlParser.COMMA); + this.state = 2426; + this.expression(); + } + } + this.state = 2431; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + this.state = 2434; + this.match(ImpalaSqlParser.RSQUARE); + } + break; + + case 24: + { + _localctx = new ColumnReferenceContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2435; + this.identifier(); + } + break; + + case 25: + { + _localctx = new SpecialDateTimeFunctionContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2436; + (_localctx as SpecialDateTimeFunctionContext)._name = this.match(ImpalaSqlParser.KW_CURRENT_DATE); + } + break; + + case 26: + { + _localctx = new SpecialDateTimeFunctionContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2437; + (_localctx as SpecialDateTimeFunctionContext)._name = this.match(ImpalaSqlParser.KW_CURRENT_TIME); + this.state = 2441; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 311, this._ctx) ) { + case 1: + { + this.state = 2438; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2439; + (_localctx as SpecialDateTimeFunctionContext)._precision = this.match(ImpalaSqlParser.INTEGER_VALUE); + this.state = 2440; + this.match(ImpalaSqlParser.RPAREN); + } + break; + } + } + break; + + case 27: + { + _localctx = new SpecialDateTimeFunctionContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2443; + (_localctx as SpecialDateTimeFunctionContext)._name = this.match(ImpalaSqlParser.KW_CURRENT_TIMESTAMP); + this.state = 2447; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 312, this._ctx) ) { + case 1: + { + this.state = 2444; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2445; + (_localctx as SpecialDateTimeFunctionContext)._precision = this.match(ImpalaSqlParser.INTEGER_VALUE); + this.state = 2446; + this.match(ImpalaSqlParser.RPAREN); + } + break; + } + } + break; + + case 28: + { + _localctx = new SpecialDateTimeFunctionContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2449; + (_localctx as SpecialDateTimeFunctionContext)._name = this.match(ImpalaSqlParser.KW_LOCALTIME); + this.state = 2453; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 313, this._ctx) ) { + case 1: + { + this.state = 2450; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2451; + (_localctx as SpecialDateTimeFunctionContext)._precision = this.match(ImpalaSqlParser.INTEGER_VALUE); + this.state = 2452; + this.match(ImpalaSqlParser.RPAREN); + } + break; + } + } + break; + + case 29: + { + _localctx = new SpecialDateTimeFunctionContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2455; + (_localctx as SpecialDateTimeFunctionContext)._name = this.match(ImpalaSqlParser.KW_LOCALTIMESTAMP); + this.state = 2459; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 314, this._ctx) ) { + case 1: + { + this.state = 2456; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2457; + (_localctx as SpecialDateTimeFunctionContext)._precision = this.match(ImpalaSqlParser.INTEGER_VALUE); + this.state = 2458; + this.match(ImpalaSqlParser.RPAREN); + } + break; + } + } + break; + + case 30: + { + _localctx = new CurrentUserContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2461; + (_localctx as CurrentUserContext)._name = this.match(ImpalaSqlParser.KW_CURRENT_USER); + } + break; + + case 31: + { + _localctx = new CurrentPathContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2462; + (_localctx as CurrentPathContext)._name = this.match(ImpalaSqlParser.KW_CURRENT_PATH); + } + break; + + case 32: + { + _localctx = new SubstringContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2463; + this.match(ImpalaSqlParser.KW_SUBSTRING); + this.state = 2464; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2465; + this.valueExpression(0); + this.state = 2466; + this.match(ImpalaSqlParser.KW_FROM); + this.state = 2467; + this.valueExpression(0); + this.state = 2470; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_FOR) { + { + this.state = 2468; + this.match(ImpalaSqlParser.KW_FOR); + this.state = 2469; + this.valueExpression(0); + } + } + + this.state = 2472; + this.match(ImpalaSqlParser.RPAREN); + } + break; + + case 33: + { + _localctx = new NormalizeContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2474; + this.match(ImpalaSqlParser.KW_NORMALIZE); + this.state = 2475; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2476; + this.valueExpression(0); + this.state = 2479; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.COMMA) { + { + this.state = 2477; + this.match(ImpalaSqlParser.COMMA); + this.state = 2478; + this.normalForm(); + } + } + + this.state = 2481; + this.match(ImpalaSqlParser.RPAREN); + } + break; + + case 34: + { + _localctx = new ExtractContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2483; + this.match(ImpalaSqlParser.KW_EXTRACT); + this.state = 2484; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2485; + this.identifier(); + this.state = 2486; + this.match(ImpalaSqlParser.KW_FROM); + this.state = 2487; + this.valueExpression(0); + this.state = 2488; + this.match(ImpalaSqlParser.RPAREN); + } + break; + + case 35: + { + _localctx = new ParenthesizedExpressionContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2490; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2491; + this.expression(); + this.state = 2492; + this.match(ImpalaSqlParser.RPAREN); + } + break; + + case 36: + { + _localctx = new GroupingOperationContext(_localctx); + this._ctx = _localctx; + _prevctx = _localctx; + this.state = 2494; + this.match(ImpalaSqlParser.KW_GROUPING); + this.state = 2495; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2504; + this._errHandler.sync(this); + _la = this._input.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ImpalaSqlParser.KW_ADD) | (1 << ImpalaSqlParser.KW_ALL) | (1 << ImpalaSqlParser.KW_ANY) | (1 << ImpalaSqlParser.KW_ARRAY) | (1 << ImpalaSqlParser.KW_ASC) | (1 << ImpalaSqlParser.KW_AT) | (1 << ImpalaSqlParser.KW_BERNOULLI) | (1 << ImpalaSqlParser.KW_CASCADE))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (ImpalaSqlParser.KW_COLUMN - 32)) | (1 << (ImpalaSqlParser.KW_COLUMNS - 32)) | (1 << (ImpalaSqlParser.KW_COMMENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT - 32)) | (1 << (ImpalaSqlParser.KW_DATA - 32)) | (1 << (ImpalaSqlParser.KW_DATABASE - 32)) | (1 << (ImpalaSqlParser.KW_DATABASES - 32)) | (1 << (ImpalaSqlParser.KW_DAY - 32)) | (1 << (ImpalaSqlParser.KW_DAYS - 32)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 32)) | (1 << (ImpalaSqlParser.KW_DESC - 32)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (ImpalaSqlParser.KW_EXCLUDING - 65)) | (1 << (ImpalaSqlParser.KW_EXPLAIN - 65)) | (1 << (ImpalaSqlParser.KW_FILTER - 65)) | (1 << (ImpalaSqlParser.KW_FIRST - 65)) | (1 << (ImpalaSqlParser.KW_FOLLOWING - 65)) | (1 << (ImpalaSqlParser.KW_FORMAT - 65)) | (1 << (ImpalaSqlParser.KW_FUNCTIONS - 65)) | (1 << (ImpalaSqlParser.KW_GRANT - 65)) | (1 << (ImpalaSqlParser.KW_HOUR - 65)) | (1 << (ImpalaSqlParser.KW_IF - 65)) | (1 << (ImpalaSqlParser.KW_INCLUDING - 65)))) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (ImpalaSqlParser.KW_INTERVAL - 101)) | (1 << (ImpalaSqlParser.KW_LAST - 101)) | (1 << (ImpalaSqlParser.KW_LATERAL - 101)) | (1 << (ImpalaSqlParser.KW_LIMIT - 101)) | (1 << (ImpalaSqlParser.KW_MAP - 101)) | (1 << (ImpalaSqlParser.KW_MINUTE - 101)) | (1 << (ImpalaSqlParser.KW_MONTH - 101)) | (1 << (ImpalaSqlParser.KW_NFC - 101)) | (1 << (ImpalaSqlParser.KW_NFD - 101)) | (1 << (ImpalaSqlParser.KW_NFKC - 101)) | (1 << (ImpalaSqlParser.KW_NFKD - 101)))) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & ((1 << (ImpalaSqlParser.KW_NULLS - 133)) | (1 << (ImpalaSqlParser.KW_OFFSET - 133)) | (1 << (ImpalaSqlParser.KW_OPTION - 133)) | (1 << (ImpalaSqlParser.KW_ORDINALITY - 133)) | (1 << (ImpalaSqlParser.KW_OVER - 133)) | (1 << (ImpalaSqlParser.KW_PARTITION - 133)) | (1 << (ImpalaSqlParser.KW_PARTITIONS - 133)) | (1 << (ImpalaSqlParser.KW_PARQUET - 133)) | (1 << (ImpalaSqlParser.KW_POSITION - 133)) | (1 << (ImpalaSqlParser.KW_PRECEDING - 133)) | (1 << (ImpalaSqlParser.KW_PRIVILEGES - 133)) | (1 << (ImpalaSqlParser.KW_PROPERTIES - 133)) | (1 << (ImpalaSqlParser.KW_RANGE - 133)) | (1 << (ImpalaSqlParser.KW_RENAME - 133)) | (1 << (ImpalaSqlParser.KW_REPEATABLE - 133)) | (1 << (ImpalaSqlParser.KW_REPLACE - 133)) | (1 << (ImpalaSqlParser.KW_RESTRICT - 133)) | (1 << (ImpalaSqlParser.KW_REVOKE - 133)))) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & ((1 << (ImpalaSqlParser.KW_ROLE - 165)) | (1 << (ImpalaSqlParser.KW_ROLES - 165)) | (1 << (ImpalaSqlParser.KW_ROW - 165)) | (1 << (ImpalaSqlParser.KW_ROWS - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMA - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMAS - 165)) | (1 << (ImpalaSqlParser.KW_SECOND - 165)) | (1 << (ImpalaSqlParser.KW_SECONDS - 165)) | (1 << (ImpalaSqlParser.KW_SET - 165)) | (1 << (ImpalaSqlParser.KW_SHOW - 165)) | (1 << (ImpalaSqlParser.KW_SOME - 165)) | (1 << (ImpalaSqlParser.KW_STATS - 165)) | (1 << (ImpalaSqlParser.KW_SUBSTRING - 165)) | (1 << (ImpalaSqlParser.KW_SYSTEM - 165)) | (1 << (ImpalaSqlParser.KW_TABLES - 165)) | (1 << (ImpalaSqlParser.KW_TABLESAMPLE - 165)) | (1 << (ImpalaSqlParser.KW_TO - 165)) | (1 << (ImpalaSqlParser.KW_TRY_CAST - 165)) | (1 << (ImpalaSqlParser.KW_TRUNCATE - 165)))) !== 0) || ((((_la - 199)) & ~0x1F) === 0 && ((1 << (_la - 199)) & ((1 << (ImpalaSqlParser.KW_UNBOUNDED - 199)) | (1 << (ImpalaSqlParser.KW_USE - 199)) | (1 << (ImpalaSqlParser.KW_USER - 199)) | (1 << (ImpalaSqlParser.KW_VIEW - 199)) | (1 << (ImpalaSqlParser.KW_VIEWS - 199)) | (1 << (ImpalaSqlParser.KW_YEAR - 199)) | (1 << (ImpalaSqlParser.KW_TEXTFILE - 199)) | (1 << (ImpalaSqlParser.KW_ORC - 199)) | (1 << (ImpalaSqlParser.KW_AVRO - 199)) | (1 << (ImpalaSqlParser.KW_SEQUENCEFILE - 199)) | (1 << (ImpalaSqlParser.KW_RCFILE - 199)))) !== 0) || ((((_la - 255)) & ~0x1F) === 0 && ((1 << (_la - 255)) & ((1 << (ImpalaSqlParser.STRING - 255)) | (1 << (ImpalaSqlParser.IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.DIGIT_IDENTIFIER - 255)) | (1 << (ImpalaSqlParser.BACKQUOTED_IDENTIFIER - 255)))) !== 0)) { + { + this.state = 2496; + this.qualifiedName(); + this.state = 2501; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2497; + this.match(ImpalaSqlParser.COMMA); + this.state = 2498; + this.qualifiedName(); + } + } + this.state = 2503; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + this.state = 2506; + this.match(ImpalaSqlParser.RPAREN); + } + break; + } + this._ctx._stop = this._input.tryLT(-1); + this.state = 2519; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 321, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + if (this._parseListeners != null) { + this.triggerExitRuleEvent(); + } + _prevctx = _localctx; + { + this.state = 2517; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 320, this._ctx) ) { + case 1: + { + _localctx = new SubscriptContext(new PrimaryExpressionContext(_parentctx, _parentState)); + (_localctx as SubscriptContext)._value = _prevctx; + this.pushNewRecursionContext(_localctx, _startState, ImpalaSqlParser.RULE_primaryExpression); + this.state = 2509; + if (!(this.precpred(this._ctx, 15))) { + throw this.createFailedPredicateException("this.precpred(this._ctx, 15)"); + } + this.state = 2510; + this.match(ImpalaSqlParser.LSQUARE); + this.state = 2511; + (_localctx as SubscriptContext)._index = this.valueExpression(0); + this.state = 2512; + this.match(ImpalaSqlParser.RSQUARE); + } + break; + + case 2: + { + _localctx = new DereferenceContext(new PrimaryExpressionContext(_parentctx, _parentState)); + (_localctx as DereferenceContext)._base = _prevctx; + this.pushNewRecursionContext(_localctx, _startState, ImpalaSqlParser.RULE_primaryExpression); + this.state = 2514; + if (!(this.precpred(this._ctx, 13))) { + throw this.createFailedPredicateException("this.precpred(this._ctx, 13)"); + } + this.state = 2515; + this.match(ImpalaSqlParser.DOT); + this.state = 2516; + (_localctx as DereferenceContext)._fieldName = this.identifier(); + } + break; + } + } + } + this.state = 2521; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 321, this._ctx); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.unrollRecursionContexts(_parentctx); + } + return _localctx; + } + // @RuleVersion(0) + public stringLiteral(): StringLiteralContext { + let _localctx: StringLiteralContext = new StringLiteralContext(this._ctx, this.state); + this.enterRule(_localctx, 312, ImpalaSqlParser.RULE_stringLiteral); + try { + this.state = 2528; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.STRING: + _localctx = new BasicStringLiteralContext(_localctx); + this.enterOuterAlt(_localctx, 1); + { + this.state = 2522; + this.match(ImpalaSqlParser.STRING); + } + break; + case ImpalaSqlParser.UNICODE_STRING: + _localctx = new UnicodeStringLiteralContext(_localctx); + this.enterOuterAlt(_localctx, 2); + { + this.state = 2523; + this.match(ImpalaSqlParser.UNICODE_STRING); + this.state = 2526; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 322, this._ctx) ) { + case 1: + { + this.state = 2524; + this.match(ImpalaSqlParser.KW_UESCAPE); + this.state = 2525; + this.match(ImpalaSqlParser.STRING); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public comparisonOperator(): ComparisonOperatorContext { + let _localctx: ComparisonOperatorContext = new ComparisonOperatorContext(this._ctx, this.state); + this.enterRule(_localctx, 314, ImpalaSqlParser.RULE_comparisonOperator); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2530; + _la = this._input.LA(1); + if (!(((((_la - 230)) & ~0x1F) === 0 && ((1 << (_la - 230)) & ((1 << (ImpalaSqlParser.EQ - 230)) | (1 << (ImpalaSqlParser.NEQ - 230)) | (1 << (ImpalaSqlParser.LT - 230)) | (1 << (ImpalaSqlParser.LTE - 230)) | (1 << (ImpalaSqlParser.GT - 230)) | (1 << (ImpalaSqlParser.GTE - 230)))) !== 0))) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public comparisonQuantifier(): ComparisonQuantifierContext { + let _localctx: ComparisonQuantifierContext = new ComparisonQuantifierContext(this._ctx, this.state); + this.enterRule(_localctx, 316, ImpalaSqlParser.RULE_comparisonQuantifier); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2532; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_ALL || _la === ImpalaSqlParser.KW_ANY || _la === ImpalaSqlParser.KW_SOME)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public booleanValue(): BooleanValueContext { + let _localctx: BooleanValueContext = new BooleanValueContext(this._ctx, this.state); + this.enterRule(_localctx, 318, ImpalaSqlParser.RULE_booleanValue); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2534; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_FALSE || _la === ImpalaSqlParser.KW_TRUE)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public interval(): IntervalContext { + let _localctx: IntervalContext = new IntervalContext(this._ctx, this.state); + this.enterRule(_localctx, 320, ImpalaSqlParser.RULE_interval); + try { + this.state = 2550; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 324, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 2536; + this.match(ImpalaSqlParser.INTEGER_VALUE); + this.state = 2537; + this.intervalField(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 2538; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2539; + this.match(ImpalaSqlParser.INTEGER_VALUE); + this.state = 2540; + this.match(ImpalaSqlParser.RPAREN); + this.state = 2541; + this.intervalField(); + } + break; + + case 3: + this.enterOuterAlt(_localctx, 3); + { + this.state = 2542; + this.match(ImpalaSqlParser.KW_INTERVAL); + this.state = 2543; + this.match(ImpalaSqlParser.INTEGER_VALUE); + this.state = 2544; + this.intervalField(); + } + break; + + case 4: + this.enterOuterAlt(_localctx, 4); + { + this.state = 2545; + this.match(ImpalaSqlParser.KW_INTERVAL); + this.state = 2546; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2547; + this.match(ImpalaSqlParser.INTEGER_VALUE); + this.state = 2548; + this.match(ImpalaSqlParser.RPAREN); + this.state = 2549; + this.intervalField(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public intervalField(): IntervalFieldContext { + let _localctx: IntervalFieldContext = new IntervalFieldContext(this._ctx, this.state); + this.enterRule(_localctx, 322, ImpalaSqlParser.RULE_intervalField); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2552; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_DAY || _la === ImpalaSqlParser.KW_DAYS || ((((_la - 91)) & ~0x1F) === 0 && ((1 << (_la - 91)) & ((1 << (ImpalaSqlParser.KW_HOUR - 91)) | (1 << (ImpalaSqlParser.KW_HOURS - 91)) | (1 << (ImpalaSqlParser.KW_MINUTE - 91)) | (1 << (ImpalaSqlParser.KW_MINUTES - 91)))) !== 0) || _la === ImpalaSqlParser.KW_MONTH || _la === ImpalaSqlParser.KW_MONTHS || _la === ImpalaSqlParser.KW_SECOND || _la === ImpalaSqlParser.KW_SECONDS || _la === ImpalaSqlParser.KW_YEAR || _la === ImpalaSqlParser.KW_YEARS)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public normalForm(): NormalFormContext { + let _localctx: NormalFormContext = new NormalFormContext(this._ctx, this.state); + this.enterRule(_localctx, 324, ImpalaSqlParser.RULE_normalForm); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2554; + _la = this._input.LA(1); + if (!(((((_la - 126)) & ~0x1F) === 0 && ((1 << (_la - 126)) & ((1 << (ImpalaSqlParser.KW_NFC - 126)) | (1 << (ImpalaSqlParser.KW_NFD - 126)) | (1 << (ImpalaSqlParser.KW_NFKC - 126)) | (1 << (ImpalaSqlParser.KW_NFKD - 126)))) !== 0))) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + + public type(): TypeContext; + public type(_p: number): TypeContext; + // @RuleVersion(0) + public type(_p?: number): TypeContext { + if (_p === undefined) { + _p = 0; + } + + let _parentctx: ParserRuleContext = this._ctx; + let _parentState: number = this.state; + let _localctx: TypeContext = new TypeContext(this._ctx, _parentState); + let _prevctx: TypeContext = _localctx; + let _startState: number = 326; + this.enterRecursionRule(_localctx, 326, ImpalaSqlParser.RULE_type, _p); + let _la: number; + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 2600; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 328, this._ctx) ) { + case 1: + { + this.state = 2557; + this.match(ImpalaSqlParser.KW_ARRAY); + this.state = 2558; + this.match(ImpalaSqlParser.LT); + this.state = 2559; + this.type(0); + this.state = 2560; + this.match(ImpalaSqlParser.GT); + } + break; + + case 2: + { + this.state = 2562; + this.match(ImpalaSqlParser.KW_MAP); + this.state = 2563; + this.match(ImpalaSqlParser.LT); + this.state = 2564; + this.type(0); + this.state = 2565; + this.match(ImpalaSqlParser.COMMA); + this.state = 2566; + this.type(0); + this.state = 2567; + this.match(ImpalaSqlParser.GT); + } + break; + + case 3: + { + this.state = 2569; + this.match(ImpalaSqlParser.KW_STRUCT); + this.state = 2570; + this.match(ImpalaSqlParser.LT); + this.state = 2571; + this.identifier(); + this.state = 2572; + this.match(ImpalaSqlParser.COLON); + this.state = 2573; + this.type(0); + this.state = 2581; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2574; + this.match(ImpalaSqlParser.COMMA); + this.state = 2575; + this.identifier(); + this.state = 2576; + this.match(ImpalaSqlParser.COLON); + this.state = 2577; + this.type(0); + } + } + this.state = 2583; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 2584; + this.match(ImpalaSqlParser.GT); + } + break; + + case 4: + { + this.state = 2586; + this.baseType(); + this.state = 2598; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 327, this._ctx) ) { + case 1: + { + this.state = 2587; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2588; + this.typeParameter(); + this.state = 2593; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2589; + this.match(ImpalaSqlParser.COMMA); + this.state = 2590; + this.typeParameter(); + } + } + this.state = 2595; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 2596; + this.match(ImpalaSqlParser.RPAREN); + } + break; + } + } + break; + } + this._ctx._stop = this._input.tryLT(-1); + this.state = 2606; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 329, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + if (this._parseListeners != null) { + this.triggerExitRuleEvent(); + } + _prevctx = _localctx; + { + { + _localctx = new TypeContext(_parentctx, _parentState); + this.pushNewRecursionContext(_localctx, _startState, ImpalaSqlParser.RULE_type); + this.state = 2602; + if (!(this.precpred(this._ctx, 5))) { + throw this.createFailedPredicateException("this.precpred(this._ctx, 5)"); + } + this.state = 2603; + this.match(ImpalaSqlParser.KW_ARRAY); + } + } + } + this.state = 2608; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 329, this._ctx); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.unrollRecursionContexts(_parentctx); + } + return _localctx; + } + // @RuleVersion(0) + public typeParameter(): TypeParameterContext { + let _localctx: TypeParameterContext = new TypeParameterContext(this._ctx, this.state); + this.enterRule(_localctx, 328, ImpalaSqlParser.RULE_typeParameter); + try { + this.state = 2611; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.INTEGER_VALUE: + this.enterOuterAlt(_localctx, 1); + { + this.state = 2609; + this.match(ImpalaSqlParser.INTEGER_VALUE); + } + break; + case ImpalaSqlParser.KW_ADD: + case ImpalaSqlParser.KW_ALL: + case ImpalaSqlParser.KW_ANY: + case ImpalaSqlParser.KW_ARRAY: + case ImpalaSqlParser.KW_ASC: + case ImpalaSqlParser.KW_AT: + case ImpalaSqlParser.KW_BERNOULLI: + case ImpalaSqlParser.KW_CASCADE: + case ImpalaSqlParser.KW_COLUMN: + case ImpalaSqlParser.KW_COLUMNS: + case ImpalaSqlParser.KW_COMMENT: + case ImpalaSqlParser.KW_CURRENT: + case ImpalaSqlParser.KW_DATA: + case ImpalaSqlParser.KW_DATABASE: + case ImpalaSqlParser.KW_DATABASES: + case ImpalaSqlParser.KW_DAY: + case ImpalaSqlParser.KW_DAYS: + case ImpalaSqlParser.KW_DEFAULT: + case ImpalaSqlParser.KW_DESC: + case ImpalaSqlParser.KW_EXCLUDING: + case ImpalaSqlParser.KW_EXPLAIN: + case ImpalaSqlParser.KW_FILTER: + case ImpalaSqlParser.KW_FIRST: + case ImpalaSqlParser.KW_FOLLOWING: + case ImpalaSqlParser.KW_FORMAT: + case ImpalaSqlParser.KW_FUNCTIONS: + case ImpalaSqlParser.KW_GRANT: + case ImpalaSqlParser.KW_HOUR: + case ImpalaSqlParser.KW_IF: + case ImpalaSqlParser.KW_INCLUDING: + case ImpalaSqlParser.KW_INTERVAL: + case ImpalaSqlParser.KW_LAST: + case ImpalaSqlParser.KW_LATERAL: + case ImpalaSqlParser.KW_LIMIT: + case ImpalaSqlParser.KW_MAP: + case ImpalaSqlParser.KW_MINUTE: + case ImpalaSqlParser.KW_MONTH: + case ImpalaSqlParser.KW_NFC: + case ImpalaSqlParser.KW_NFD: + case ImpalaSqlParser.KW_NFKC: + case ImpalaSqlParser.KW_NFKD: + case ImpalaSqlParser.KW_NULLS: + case ImpalaSqlParser.KW_OFFSET: + case ImpalaSqlParser.KW_OPTION: + case ImpalaSqlParser.KW_ORDINALITY: + case ImpalaSqlParser.KW_OVER: + case ImpalaSqlParser.KW_PARTITION: + case ImpalaSqlParser.KW_PARTITIONS: + case ImpalaSqlParser.KW_PARQUET: + case ImpalaSqlParser.KW_POSITION: + case ImpalaSqlParser.KW_PRECEDING: + case ImpalaSqlParser.KW_PRIVILEGES: + case ImpalaSqlParser.KW_PROPERTIES: + case ImpalaSqlParser.KW_RANGE: + case ImpalaSqlParser.KW_RENAME: + case ImpalaSqlParser.KW_REPEATABLE: + case ImpalaSqlParser.KW_REPLACE: + case ImpalaSqlParser.KW_RESTRICT: + case ImpalaSqlParser.KW_REVOKE: + case ImpalaSqlParser.KW_ROLE: + case ImpalaSqlParser.KW_ROLES: + case ImpalaSqlParser.KW_ROW: + case ImpalaSqlParser.KW_ROWS: + case ImpalaSqlParser.KW_SCHEMA: + case ImpalaSqlParser.KW_SCHEMAS: + case ImpalaSqlParser.KW_SECOND: + case ImpalaSqlParser.KW_SECONDS: + case ImpalaSqlParser.KW_SET: + case ImpalaSqlParser.KW_SHOW: + case ImpalaSqlParser.KW_SOME: + case ImpalaSqlParser.KW_STATS: + case ImpalaSqlParser.KW_STRUCT: + case ImpalaSqlParser.KW_SUBSTRING: + case ImpalaSqlParser.KW_SYSTEM: + case ImpalaSqlParser.KW_TABLES: + case ImpalaSqlParser.KW_TABLESAMPLE: + case ImpalaSqlParser.KW_TO: + case ImpalaSqlParser.KW_TRY_CAST: + case ImpalaSqlParser.KW_TRUNCATE: + case ImpalaSqlParser.KW_UNBOUNDED: + case ImpalaSqlParser.KW_USE: + case ImpalaSqlParser.KW_USER: + case ImpalaSqlParser.KW_VIEW: + case ImpalaSqlParser.KW_VIEWS: + case ImpalaSqlParser.KW_YEAR: + case ImpalaSqlParser.KW_TEXTFILE: + case ImpalaSqlParser.KW_ORC: + case ImpalaSqlParser.KW_AVRO: + case ImpalaSqlParser.KW_SEQUENCEFILE: + case ImpalaSqlParser.KW_RCFILE: + case ImpalaSqlParser.STRING: + case ImpalaSqlParser.IDENTIFIER: + case ImpalaSqlParser.DIGIT_IDENTIFIER: + case ImpalaSqlParser.BACKQUOTED_IDENTIFIER: + case ImpalaSqlParser.TIME_WITH_TIME_ZONE: + case ImpalaSqlParser.TIMESTAMP_WITH_TIME_ZONE: + case ImpalaSqlParser.DOUBLE_PRECISION: + this.enterOuterAlt(_localctx, 2); + { + this.state = 2610; + this.type(0); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public baseType(): BaseTypeContext { + let _localctx: BaseTypeContext = new BaseTypeContext(this._ctx, this.state); + this.enterRule(_localctx, 330, ImpalaSqlParser.RULE_baseType); + try { + this.state = 2617; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.TIME_WITH_TIME_ZONE: + this.enterOuterAlt(_localctx, 1); + { + this.state = 2613; + this.match(ImpalaSqlParser.TIME_WITH_TIME_ZONE); + } + break; + case ImpalaSqlParser.TIMESTAMP_WITH_TIME_ZONE: + this.enterOuterAlt(_localctx, 2); + { + this.state = 2614; + this.match(ImpalaSqlParser.TIMESTAMP_WITH_TIME_ZONE); + } + break; + case ImpalaSqlParser.DOUBLE_PRECISION: + this.enterOuterAlt(_localctx, 3); + { + this.state = 2615; + this.match(ImpalaSqlParser.DOUBLE_PRECISION); + } + break; + case ImpalaSqlParser.KW_ADD: + case ImpalaSqlParser.KW_ALL: + case ImpalaSqlParser.KW_ANY: + case ImpalaSqlParser.KW_ARRAY: + case ImpalaSqlParser.KW_ASC: + case ImpalaSqlParser.KW_AT: + case ImpalaSqlParser.KW_BERNOULLI: + case ImpalaSqlParser.KW_CASCADE: + case ImpalaSqlParser.KW_COLUMN: + case ImpalaSqlParser.KW_COLUMNS: + case ImpalaSqlParser.KW_COMMENT: + case ImpalaSqlParser.KW_CURRENT: + case ImpalaSqlParser.KW_DATA: + case ImpalaSqlParser.KW_DATABASE: + case ImpalaSqlParser.KW_DATABASES: + case ImpalaSqlParser.KW_DAY: + case ImpalaSqlParser.KW_DAYS: + case ImpalaSqlParser.KW_DEFAULT: + case ImpalaSqlParser.KW_DESC: + case ImpalaSqlParser.KW_EXCLUDING: + case ImpalaSqlParser.KW_EXPLAIN: + case ImpalaSqlParser.KW_FILTER: + case ImpalaSqlParser.KW_FIRST: + case ImpalaSqlParser.KW_FOLLOWING: + case ImpalaSqlParser.KW_FORMAT: + case ImpalaSqlParser.KW_FUNCTIONS: + case ImpalaSqlParser.KW_GRANT: + case ImpalaSqlParser.KW_HOUR: + case ImpalaSqlParser.KW_IF: + case ImpalaSqlParser.KW_INCLUDING: + case ImpalaSqlParser.KW_INTERVAL: + case ImpalaSqlParser.KW_LAST: + case ImpalaSqlParser.KW_LATERAL: + case ImpalaSqlParser.KW_LIMIT: + case ImpalaSqlParser.KW_MAP: + case ImpalaSqlParser.KW_MINUTE: + case ImpalaSqlParser.KW_MONTH: + case ImpalaSqlParser.KW_NFC: + case ImpalaSqlParser.KW_NFD: + case ImpalaSqlParser.KW_NFKC: + case ImpalaSqlParser.KW_NFKD: + case ImpalaSqlParser.KW_NULLS: + case ImpalaSqlParser.KW_OFFSET: + case ImpalaSqlParser.KW_OPTION: + case ImpalaSqlParser.KW_ORDINALITY: + case ImpalaSqlParser.KW_OVER: + case ImpalaSqlParser.KW_PARTITION: + case ImpalaSqlParser.KW_PARTITIONS: + case ImpalaSqlParser.KW_PARQUET: + case ImpalaSqlParser.KW_POSITION: + case ImpalaSqlParser.KW_PRECEDING: + case ImpalaSqlParser.KW_PRIVILEGES: + case ImpalaSqlParser.KW_PROPERTIES: + case ImpalaSqlParser.KW_RANGE: + case ImpalaSqlParser.KW_RENAME: + case ImpalaSqlParser.KW_REPEATABLE: + case ImpalaSqlParser.KW_REPLACE: + case ImpalaSqlParser.KW_RESTRICT: + case ImpalaSqlParser.KW_REVOKE: + case ImpalaSqlParser.KW_ROLE: + case ImpalaSqlParser.KW_ROLES: + case ImpalaSqlParser.KW_ROW: + case ImpalaSqlParser.KW_ROWS: + case ImpalaSqlParser.KW_SCHEMA: + case ImpalaSqlParser.KW_SCHEMAS: + case ImpalaSqlParser.KW_SECOND: + case ImpalaSqlParser.KW_SECONDS: + case ImpalaSqlParser.KW_SET: + case ImpalaSqlParser.KW_SHOW: + case ImpalaSqlParser.KW_SOME: + case ImpalaSqlParser.KW_STATS: + case ImpalaSqlParser.KW_SUBSTRING: + case ImpalaSqlParser.KW_SYSTEM: + case ImpalaSqlParser.KW_TABLES: + case ImpalaSqlParser.KW_TABLESAMPLE: + case ImpalaSqlParser.KW_TO: + case ImpalaSqlParser.KW_TRY_CAST: + case ImpalaSqlParser.KW_TRUNCATE: + case ImpalaSqlParser.KW_UNBOUNDED: + case ImpalaSqlParser.KW_USE: + case ImpalaSqlParser.KW_USER: + case ImpalaSqlParser.KW_VIEW: + case ImpalaSqlParser.KW_VIEWS: + case ImpalaSqlParser.KW_YEAR: + case ImpalaSqlParser.KW_TEXTFILE: + case ImpalaSqlParser.KW_ORC: + case ImpalaSqlParser.KW_AVRO: + case ImpalaSqlParser.KW_SEQUENCEFILE: + case ImpalaSqlParser.KW_RCFILE: + case ImpalaSqlParser.STRING: + case ImpalaSqlParser.IDENTIFIER: + case ImpalaSqlParser.DIGIT_IDENTIFIER: + case ImpalaSqlParser.BACKQUOTED_IDENTIFIER: + this.enterOuterAlt(_localctx, 4); + { + this.state = 2616; + this.identifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public whenClause(): WhenClauseContext { + let _localctx: WhenClauseContext = new WhenClauseContext(this._ctx, this.state); + this.enterRule(_localctx, 332, ImpalaSqlParser.RULE_whenClause); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2619; + this.match(ImpalaSqlParser.KW_WHEN); + this.state = 2620; + _localctx._condition = this.expression(); + this.state = 2621; + this.match(ImpalaSqlParser.KW_THEN); + this.state = 2622; + _localctx._result = this.expression(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public filter(): FilterContext { + let _localctx: FilterContext = new FilterContext(this._ctx, this.state); + this.enterRule(_localctx, 334, ImpalaSqlParser.RULE_filter); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2624; + this.match(ImpalaSqlParser.KW_FILTER); + this.state = 2625; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2626; + this.match(ImpalaSqlParser.KW_WHERE); + this.state = 2627; + this.booleanExpression(0); + this.state = 2628; + this.match(ImpalaSqlParser.RPAREN); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public over(): OverContext { + let _localctx: OverContext = new OverContext(this._ctx, this.state); + this.enterRule(_localctx, 336, ImpalaSqlParser.RULE_over); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2630; + this.match(ImpalaSqlParser.KW_OVER); + this.state = 2631; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2642; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_PARTITION) { + { + this.state = 2632; + this.match(ImpalaSqlParser.KW_PARTITION); + this.state = 2633; + this.match(ImpalaSqlParser.KW_BY); + this.state = 2634; + _localctx._expression = this.expression(); + _localctx._partition.push(_localctx._expression); + this.state = 2639; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2635; + this.match(ImpalaSqlParser.COMMA); + this.state = 2636; + _localctx._expression = this.expression(); + _localctx._partition.push(_localctx._expression); + } + } + this.state = 2641; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + this.state = 2654; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_ORDER) { + { + this.state = 2644; + this.match(ImpalaSqlParser.KW_ORDER); + this.state = 2645; + this.match(ImpalaSqlParser.KW_BY); + this.state = 2646; + this.sortItem(); + this.state = 2651; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2647; + this.match(ImpalaSqlParser.COMMA); + this.state = 2648; + this.sortItem(); + } + } + this.state = 2653; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + + this.state = 2657; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.KW_RANGE || _la === ImpalaSqlParser.KW_ROWS) { + { + this.state = 2656; + this.windowFrame(); + } + } + + this.state = 2659; + this.match(ImpalaSqlParser.RPAREN); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public windowFrame(): WindowFrameContext { + let _localctx: WindowFrameContext = new WindowFrameContext(this._ctx, this.state); + this.enterRule(_localctx, 338, ImpalaSqlParser.RULE_windowFrame); + try { + this.state = 2677; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 337, this._ctx) ) { + case 1: + this.enterOuterAlt(_localctx, 1); + { + this.state = 2661; + _localctx._frameType = this.match(ImpalaSqlParser.KW_RANGE); + this.state = 2662; + _localctx._start_ = this.frameBound(); + } + break; + + case 2: + this.enterOuterAlt(_localctx, 2); + { + this.state = 2663; + _localctx._frameType = this.match(ImpalaSqlParser.KW_ROWS); + this.state = 2664; + _localctx._start_ = this.frameBound(); + } + break; + + case 3: + this.enterOuterAlt(_localctx, 3); + { + this.state = 2665; + _localctx._frameType = this.match(ImpalaSqlParser.KW_RANGE); + this.state = 2666; + this.match(ImpalaSqlParser.KW_BETWEEN); + this.state = 2667; + _localctx._start_ = this.frameBound(); + this.state = 2668; + this.match(ImpalaSqlParser.KW_AND); + this.state = 2669; + _localctx._end = this.frameBound(); + } + break; + + case 4: + this.enterOuterAlt(_localctx, 4); + { + this.state = 2671; + _localctx._frameType = this.match(ImpalaSqlParser.KW_ROWS); + this.state = 2672; + this.match(ImpalaSqlParser.KW_BETWEEN); + this.state = 2673; + _localctx._start_ = this.frameBound(); + this.state = 2674; + this.match(ImpalaSqlParser.KW_AND); + this.state = 2675; + _localctx._end = this.frameBound(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public frameBound(): FrameBoundContext { + let _localctx: FrameBoundContext = new FrameBoundContext(this._ctx, this.state); + this.enterRule(_localctx, 340, ImpalaSqlParser.RULE_frameBound); + let _la: number; + try { + this.state = 2688; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 338, this._ctx) ) { + case 1: + _localctx = new UnboundedFrameContext(_localctx); + this.enterOuterAlt(_localctx, 1); + { + this.state = 2679; + this.match(ImpalaSqlParser.KW_UNBOUNDED); + this.state = 2680; + (_localctx as UnboundedFrameContext)._boundType = this.match(ImpalaSqlParser.KW_PRECEDING); + } + break; + + case 2: + _localctx = new UnboundedFrameContext(_localctx); + this.enterOuterAlt(_localctx, 2); + { + this.state = 2681; + this.match(ImpalaSqlParser.KW_UNBOUNDED); + this.state = 2682; + (_localctx as UnboundedFrameContext)._boundType = this.match(ImpalaSqlParser.KW_FOLLOWING); + } + break; + + case 3: + _localctx = new CurrentRowBoundContext(_localctx); + this.enterOuterAlt(_localctx, 3); + { + this.state = 2683; + this.match(ImpalaSqlParser.KW_CURRENT); + this.state = 2684; + this.match(ImpalaSqlParser.KW_ROW); + } + break; + + case 4: + _localctx = new BoundedFrameContext(_localctx); + this.enterOuterAlt(_localctx, 4); + { + this.state = 2685; + this.expression(); + this.state = 2686; + (_localctx as BoundedFrameContext)._boundType = this._input.LT(1); + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_FOLLOWING || _la === ImpalaSqlParser.KW_PRECEDING)) { + (_localctx as BoundedFrameContext)._boundType = this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public pathElement(): PathElementContext { + let _localctx: PathElementContext = new PathElementContext(this._ctx, this.state); + this.enterRule(_localctx, 342, ImpalaSqlParser.RULE_pathElement); + try { + this.state = 2695; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 339, this._ctx) ) { + case 1: + _localctx = new QualifiedArgumentContext(_localctx); + this.enterOuterAlt(_localctx, 1); + { + this.state = 2690; + this.identifier(); + this.state = 2691; + this.match(ImpalaSqlParser.DOT); + this.state = 2692; + this.identifier(); + } + break; + + case 2: + _localctx = new UnqualifiedArgumentContext(_localctx); + this.enterOuterAlt(_localctx, 2); + { + this.state = 2694; + this.identifier(); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public pathSpecification(): PathSpecificationContext { + let _localctx: PathSpecificationContext = new PathSpecificationContext(this._ctx, this.state); + this.enterRule(_localctx, 344, ImpalaSqlParser.RULE_pathSpecification); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2697; + this.pathElement(); + this.state = 2702; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === ImpalaSqlParser.COMMA) { + { + { + this.state = 2698; + this.match(ImpalaSqlParser.COMMA); + this.state = 2699; + this.pathElement(); + } + } + this.state = 2704; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public privilege(): PrivilegeContext { + let _localctx: PrivilegeContext = new PrivilegeContext(this._ctx, this.state); + this.enterRule(_localctx, 346, ImpalaSqlParser.RULE_privilege); + let _la: number; + try { + this.state = 2718; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_ALL: + this.enterOuterAlt(_localctx, 1); + { + this.state = 2705; + this.match(ImpalaSqlParser.KW_ALL); + } + break; + case ImpalaSqlParser.KW_ALTER: + this.enterOuterAlt(_localctx, 2); + { + this.state = 2706; + this.match(ImpalaSqlParser.KW_ALTER); + } + break; + case ImpalaSqlParser.KW_DROP: + this.enterOuterAlt(_localctx, 3); + { + this.state = 2707; + this.match(ImpalaSqlParser.KW_DROP); + } + break; + case ImpalaSqlParser.KW_CREATE: + this.enterOuterAlt(_localctx, 4); + { + this.state = 2708; + this.match(ImpalaSqlParser.KW_CREATE); + } + break; + case ImpalaSqlParser.KW_INSERT: + this.enterOuterAlt(_localctx, 5); + { + this.state = 2709; + this.match(ImpalaSqlParser.KW_INSERT); + } + break; + case ImpalaSqlParser.KW_REFRESH: + this.enterOuterAlt(_localctx, 6); + { + this.state = 2710; + this.match(ImpalaSqlParser.KW_REFRESH); + } + break; + case ImpalaSqlParser.KW_SELECT: + this.enterOuterAlt(_localctx, 7); + { + this.state = 2711; + this.match(ImpalaSqlParser.KW_SELECT); + this.state = 2716; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.LPAREN) { + { + this.state = 2712; + this.match(ImpalaSqlParser.LPAREN); + this.state = 2713; + _localctx._columnName = this.identifier(); + this.state = 2714; + this.match(ImpalaSqlParser.RPAREN); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public objectType(): ObjectTypeContext { + let _localctx: ObjectTypeContext = new ObjectTypeContext(this._ctx, this.state); + this.enterRule(_localctx, 348, ImpalaSqlParser.RULE_objectType); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2720; + _la = this._input.LA(1); + if (!(_la === ImpalaSqlParser.KW_DATABASE || ((((_la - 177)) & ~0x1F) === 0 && ((1 << (_la - 177)) & ((1 << (ImpalaSqlParser.KW_SERVER - 177)) | (1 << (ImpalaSqlParser.KW_TABLE - 177)) | (1 << (ImpalaSqlParser.KW_URI - 177)))) !== 0))) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public qualifiedName(): QualifiedNameContext { + let _localctx: QualifiedNameContext = new QualifiedNameContext(this._ctx, this.state); + this.enterRule(_localctx, 350, ImpalaSqlParser.RULE_qualifiedName); + try { + let _alt: number; + this.enterOuterAlt(_localctx, 1); + { + this.state = 2722; + this.identifier(); + this.state = 2727; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 343, this._ctx); + while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { + if (_alt === 1) { + { + { + this.state = 2723; + this.match(ImpalaSqlParser.DOT); + this.state = 2724; + this.identifier(); + } + } + } + this.state = 2729; + this._errHandler.sync(this); + _alt = this.interpreter.adaptivePredict(this._input, 343, this._ctx); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public principal(): PrincipalContext { + let _localctx: PrincipalContext = new PrincipalContext(this._ctx, this.state); + this.enterRule(_localctx, 352, ImpalaSqlParser.RULE_principal); + try { + this.state = 2736; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.KW_ROLE: + _localctx = new RolePrincipalContext(_localctx); + this.enterOuterAlt(_localctx, 1); + { + this.state = 2730; + this.match(ImpalaSqlParser.KW_ROLE); + this.state = 2731; + this.identifier(); + } + break; + case ImpalaSqlParser.KW_USER: + _localctx = new UserPrincipalContext(_localctx); + this.enterOuterAlt(_localctx, 2); + { + this.state = 2732; + this.match(ImpalaSqlParser.KW_USER); + this.state = 2733; + this.identifier(); + } + break; + case ImpalaSqlParser.KW_GROUP: + _localctx = new GroupPrincipalContext(_localctx); + this.enterOuterAlt(_localctx, 3); + { + this.state = 2734; + this.match(ImpalaSqlParser.KW_GROUP); + this.state = 2735; + this.identifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public identifier(): IdentifierContext { + let _localctx: IdentifierContext = new IdentifierContext(this._ctx, this.state); + this.enterRule(_localctx, 354, ImpalaSqlParser.RULE_identifier); + try { + this.state = 2743; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case ImpalaSqlParser.IDENTIFIER: + _localctx = new UnquotedIdentifierContext(_localctx); + this.enterOuterAlt(_localctx, 1); + { + this.state = 2738; + this.match(ImpalaSqlParser.IDENTIFIER); + } + break; + case ImpalaSqlParser.STRING: + _localctx = new QuotedIdentifierContext(_localctx); + this.enterOuterAlt(_localctx, 2); + { + this.state = 2739; + this.match(ImpalaSqlParser.STRING); + } + break; + case ImpalaSqlParser.KW_ADD: + case ImpalaSqlParser.KW_ALL: + case ImpalaSqlParser.KW_ANY: + case ImpalaSqlParser.KW_ARRAY: + case ImpalaSqlParser.KW_ASC: + case ImpalaSqlParser.KW_AT: + case ImpalaSqlParser.KW_BERNOULLI: + case ImpalaSqlParser.KW_CASCADE: + case ImpalaSqlParser.KW_COLUMN: + case ImpalaSqlParser.KW_COLUMNS: + case ImpalaSqlParser.KW_COMMENT: + case ImpalaSqlParser.KW_CURRENT: + case ImpalaSqlParser.KW_DATA: + case ImpalaSqlParser.KW_DATABASE: + case ImpalaSqlParser.KW_DATABASES: + case ImpalaSqlParser.KW_DAY: + case ImpalaSqlParser.KW_DAYS: + case ImpalaSqlParser.KW_DEFAULT: + case ImpalaSqlParser.KW_DESC: + case ImpalaSqlParser.KW_EXCLUDING: + case ImpalaSqlParser.KW_EXPLAIN: + case ImpalaSqlParser.KW_FILTER: + case ImpalaSqlParser.KW_FIRST: + case ImpalaSqlParser.KW_FOLLOWING: + case ImpalaSqlParser.KW_FORMAT: + case ImpalaSqlParser.KW_FUNCTIONS: + case ImpalaSqlParser.KW_GRANT: + case ImpalaSqlParser.KW_HOUR: + case ImpalaSqlParser.KW_IF: + case ImpalaSqlParser.KW_INCLUDING: + case ImpalaSqlParser.KW_INTERVAL: + case ImpalaSqlParser.KW_LAST: + case ImpalaSqlParser.KW_LATERAL: + case ImpalaSqlParser.KW_LIMIT: + case ImpalaSqlParser.KW_MAP: + case ImpalaSqlParser.KW_MINUTE: + case ImpalaSqlParser.KW_MONTH: + case ImpalaSqlParser.KW_NFC: + case ImpalaSqlParser.KW_NFD: + case ImpalaSqlParser.KW_NFKC: + case ImpalaSqlParser.KW_NFKD: + case ImpalaSqlParser.KW_NULLS: + case ImpalaSqlParser.KW_OFFSET: + case ImpalaSqlParser.KW_OPTION: + case ImpalaSqlParser.KW_ORDINALITY: + case ImpalaSqlParser.KW_OVER: + case ImpalaSqlParser.KW_PARTITION: + case ImpalaSqlParser.KW_PARTITIONS: + case ImpalaSqlParser.KW_PARQUET: + case ImpalaSqlParser.KW_POSITION: + case ImpalaSqlParser.KW_PRECEDING: + case ImpalaSqlParser.KW_PRIVILEGES: + case ImpalaSqlParser.KW_PROPERTIES: + case ImpalaSqlParser.KW_RANGE: + case ImpalaSqlParser.KW_RENAME: + case ImpalaSqlParser.KW_REPEATABLE: + case ImpalaSqlParser.KW_REPLACE: + case ImpalaSqlParser.KW_RESTRICT: + case ImpalaSqlParser.KW_REVOKE: + case ImpalaSqlParser.KW_ROLE: + case ImpalaSqlParser.KW_ROLES: + case ImpalaSqlParser.KW_ROW: + case ImpalaSqlParser.KW_ROWS: + case ImpalaSqlParser.KW_SCHEMA: + case ImpalaSqlParser.KW_SCHEMAS: + case ImpalaSqlParser.KW_SECOND: + case ImpalaSqlParser.KW_SECONDS: + case ImpalaSqlParser.KW_SET: + case ImpalaSqlParser.KW_SHOW: + case ImpalaSqlParser.KW_SOME: + case ImpalaSqlParser.KW_STATS: + case ImpalaSqlParser.KW_SUBSTRING: + case ImpalaSqlParser.KW_SYSTEM: + case ImpalaSqlParser.KW_TABLES: + case ImpalaSqlParser.KW_TABLESAMPLE: + case ImpalaSqlParser.KW_TO: + case ImpalaSqlParser.KW_TRY_CAST: + case ImpalaSqlParser.KW_TRUNCATE: + case ImpalaSqlParser.KW_UNBOUNDED: + case ImpalaSqlParser.KW_USE: + case ImpalaSqlParser.KW_USER: + case ImpalaSqlParser.KW_VIEW: + case ImpalaSqlParser.KW_VIEWS: + case ImpalaSqlParser.KW_YEAR: + case ImpalaSqlParser.KW_TEXTFILE: + case ImpalaSqlParser.KW_ORC: + case ImpalaSqlParser.KW_AVRO: + case ImpalaSqlParser.KW_SEQUENCEFILE: + case ImpalaSqlParser.KW_RCFILE: + _localctx = new UnquotedIdentifierContext(_localctx); + this.enterOuterAlt(_localctx, 3); + { + this.state = 2740; + this.nonReserved(); + } + break; + case ImpalaSqlParser.BACKQUOTED_IDENTIFIER: + _localctx = new BackQuotedIdentifierContext(_localctx); + this.enterOuterAlt(_localctx, 4); + { + this.state = 2741; + this.match(ImpalaSqlParser.BACKQUOTED_IDENTIFIER); + } + break; + case ImpalaSqlParser.DIGIT_IDENTIFIER: + _localctx = new DigitIdentifierContext(_localctx); + this.enterOuterAlt(_localctx, 5); + { + this.state = 2742; + this.match(ImpalaSqlParser.DIGIT_IDENTIFIER); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public number(): NumberContext { + let _localctx: NumberContext = new NumberContext(this._ctx, this.state); + this.enterRule(_localctx, 356, ImpalaSqlParser.RULE_number); + let _la: number; + try { + this.state = 2757; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 349, this._ctx) ) { + case 1: + _localctx = new DecimalLiteralContext(_localctx); + this.enterOuterAlt(_localctx, 1); + { + this.state = 2746; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.MINUS) { + { + this.state = 2745; + this.match(ImpalaSqlParser.MINUS); + } + } + + this.state = 2748; + this.match(ImpalaSqlParser.DECIMAL_VALUE); + } + break; + + case 2: + _localctx = new DoubleLiteralContext(_localctx); + this.enterOuterAlt(_localctx, 2); + { + this.state = 2750; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.MINUS) { + { + this.state = 2749; + this.match(ImpalaSqlParser.MINUS); + } + } + + this.state = 2752; + this.match(ImpalaSqlParser.DOUBLE_VALUE); + } + break; + + case 3: + _localctx = new IntegerLiteralContext(_localctx); + this.enterOuterAlt(_localctx, 3); + { + this.state = 2754; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === ImpalaSqlParser.MINUS) { + { + this.state = 2753; + this.match(ImpalaSqlParser.MINUS); + } + } + + this.state = 2756; + this.match(ImpalaSqlParser.INTEGER_VALUE); + } + break; + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public nonReserved(): NonReservedContext { + let _localctx: NonReservedContext = new NonReservedContext(this._ctx, this.state); + this.enterRule(_localctx, 358, ImpalaSqlParser.RULE_nonReserved); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2759; + _la = this._input.LA(1); + if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ImpalaSqlParser.KW_ADD) | (1 << ImpalaSqlParser.KW_ALL) | (1 << ImpalaSqlParser.KW_ANY) | (1 << ImpalaSqlParser.KW_ARRAY) | (1 << ImpalaSqlParser.KW_ASC) | (1 << ImpalaSqlParser.KW_AT) | (1 << ImpalaSqlParser.KW_BERNOULLI) | (1 << ImpalaSqlParser.KW_CASCADE))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (ImpalaSqlParser.KW_COLUMN - 32)) | (1 << (ImpalaSqlParser.KW_COLUMNS - 32)) | (1 << (ImpalaSqlParser.KW_COMMENT - 32)) | (1 << (ImpalaSqlParser.KW_CURRENT - 32)) | (1 << (ImpalaSqlParser.KW_DATA - 32)) | (1 << (ImpalaSqlParser.KW_DATABASE - 32)) | (1 << (ImpalaSqlParser.KW_DATABASES - 32)) | (1 << (ImpalaSqlParser.KW_DAY - 32)) | (1 << (ImpalaSqlParser.KW_DAYS - 32)) | (1 << (ImpalaSqlParser.KW_DEFAULT - 32)) | (1 << (ImpalaSqlParser.KW_DESC - 32)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (ImpalaSqlParser.KW_EXCLUDING - 65)) | (1 << (ImpalaSqlParser.KW_EXPLAIN - 65)) | (1 << (ImpalaSqlParser.KW_FILTER - 65)) | (1 << (ImpalaSqlParser.KW_FIRST - 65)) | (1 << (ImpalaSqlParser.KW_FOLLOWING - 65)) | (1 << (ImpalaSqlParser.KW_FORMAT - 65)) | (1 << (ImpalaSqlParser.KW_FUNCTIONS - 65)) | (1 << (ImpalaSqlParser.KW_GRANT - 65)) | (1 << (ImpalaSqlParser.KW_HOUR - 65)) | (1 << (ImpalaSqlParser.KW_IF - 65)) | (1 << (ImpalaSqlParser.KW_INCLUDING - 65)))) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (ImpalaSqlParser.KW_INTERVAL - 101)) | (1 << (ImpalaSqlParser.KW_LAST - 101)) | (1 << (ImpalaSqlParser.KW_LATERAL - 101)) | (1 << (ImpalaSqlParser.KW_LIMIT - 101)) | (1 << (ImpalaSqlParser.KW_MAP - 101)) | (1 << (ImpalaSqlParser.KW_MINUTE - 101)) | (1 << (ImpalaSqlParser.KW_MONTH - 101)) | (1 << (ImpalaSqlParser.KW_NFC - 101)) | (1 << (ImpalaSqlParser.KW_NFD - 101)) | (1 << (ImpalaSqlParser.KW_NFKC - 101)) | (1 << (ImpalaSqlParser.KW_NFKD - 101)))) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & ((1 << (ImpalaSqlParser.KW_NULLS - 133)) | (1 << (ImpalaSqlParser.KW_OFFSET - 133)) | (1 << (ImpalaSqlParser.KW_OPTION - 133)) | (1 << (ImpalaSqlParser.KW_ORDINALITY - 133)) | (1 << (ImpalaSqlParser.KW_OVER - 133)) | (1 << (ImpalaSqlParser.KW_PARTITION - 133)) | (1 << (ImpalaSqlParser.KW_PARTITIONS - 133)) | (1 << (ImpalaSqlParser.KW_PARQUET - 133)) | (1 << (ImpalaSqlParser.KW_POSITION - 133)) | (1 << (ImpalaSqlParser.KW_PRECEDING - 133)) | (1 << (ImpalaSqlParser.KW_PRIVILEGES - 133)) | (1 << (ImpalaSqlParser.KW_PROPERTIES - 133)) | (1 << (ImpalaSqlParser.KW_RANGE - 133)) | (1 << (ImpalaSqlParser.KW_RENAME - 133)) | (1 << (ImpalaSqlParser.KW_REPEATABLE - 133)) | (1 << (ImpalaSqlParser.KW_REPLACE - 133)) | (1 << (ImpalaSqlParser.KW_RESTRICT - 133)) | (1 << (ImpalaSqlParser.KW_REVOKE - 133)))) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & ((1 << (ImpalaSqlParser.KW_ROLE - 165)) | (1 << (ImpalaSqlParser.KW_ROLES - 165)) | (1 << (ImpalaSqlParser.KW_ROW - 165)) | (1 << (ImpalaSqlParser.KW_ROWS - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMA - 165)) | (1 << (ImpalaSqlParser.KW_SCHEMAS - 165)) | (1 << (ImpalaSqlParser.KW_SECOND - 165)) | (1 << (ImpalaSqlParser.KW_SECONDS - 165)) | (1 << (ImpalaSqlParser.KW_SET - 165)) | (1 << (ImpalaSqlParser.KW_SHOW - 165)) | (1 << (ImpalaSqlParser.KW_SOME - 165)) | (1 << (ImpalaSqlParser.KW_STATS - 165)) | (1 << (ImpalaSqlParser.KW_SUBSTRING - 165)) | (1 << (ImpalaSqlParser.KW_SYSTEM - 165)) | (1 << (ImpalaSqlParser.KW_TABLES - 165)) | (1 << (ImpalaSqlParser.KW_TABLESAMPLE - 165)) | (1 << (ImpalaSqlParser.KW_TO - 165)) | (1 << (ImpalaSqlParser.KW_TRY_CAST - 165)) | (1 << (ImpalaSqlParser.KW_TRUNCATE - 165)))) !== 0) || ((((_la - 199)) & ~0x1F) === 0 && ((1 << (_la - 199)) & ((1 << (ImpalaSqlParser.KW_UNBOUNDED - 199)) | (1 << (ImpalaSqlParser.KW_USE - 199)) | (1 << (ImpalaSqlParser.KW_USER - 199)) | (1 << (ImpalaSqlParser.KW_VIEW - 199)) | (1 << (ImpalaSqlParser.KW_VIEWS - 199)) | (1 << (ImpalaSqlParser.KW_YEAR - 199)) | (1 << (ImpalaSqlParser.KW_TEXTFILE - 199)) | (1 << (ImpalaSqlParser.KW_ORC - 199)) | (1 << (ImpalaSqlParser.KW_AVRO - 199)) | (1 << (ImpalaSqlParser.KW_SEQUENCEFILE - 199)) | (1 << (ImpalaSqlParser.KW_RCFILE - 199)))) !== 0))) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + + public sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean { + switch (ruleIndex) { + case 128: + return this.queryTerm_sempred(_localctx as QueryTermContext, predIndex); + + case 138: + return this.relation_sempred(_localctx as RelationContext, predIndex); + + case 152: + return this.booleanExpression_sempred(_localctx as BooleanExpressionContext, predIndex); + + case 154: + return this.valueExpression_sempred(_localctx as ValueExpressionContext, predIndex); + + case 155: + return this.primaryExpression_sempred(_localctx as PrimaryExpressionContext, predIndex); + + case 163: + return this.type_sempred(_localctx as TypeContext, predIndex); + } + return true; + } + private queryTerm_sempred(_localctx: QueryTermContext, predIndex: number): boolean { + switch (predIndex) { + case 0: + return this.precpred(this._ctx, 2); + + case 1: + return this.precpred(this._ctx, 1); + } + return true; + } + private relation_sempred(_localctx: RelationContext, predIndex: number): boolean { + switch (predIndex) { + case 2: + return this.precpred(this._ctx, 2); + } + return true; + } + private booleanExpression_sempred(_localctx: BooleanExpressionContext, predIndex: number): boolean { + switch (predIndex) { + case 3: + return this.precpred(this._ctx, 2); + + case 4: + return this.precpred(this._ctx, 1); + } + return true; + } + private valueExpression_sempred(_localctx: ValueExpressionContext, predIndex: number): boolean { + switch (predIndex) { + case 5: + return this.precpred(this._ctx, 3); + + case 6: + return this.precpred(this._ctx, 2); + + case 7: + return this.precpred(this._ctx, 1); + } + return true; + } + private primaryExpression_sempred(_localctx: PrimaryExpressionContext, predIndex: number): boolean { + switch (predIndex) { + case 8: + return this.precpred(this._ctx, 15); + + case 9: + return this.precpred(this._ctx, 13); + } + return true; + } + private type_sempred(_localctx: TypeContext, predIndex: number): boolean { + switch (predIndex) { + case 10: + return this.precpred(this._ctx, 5); + } + return true; + } + + private static readonly _serializedATNSegments: number = 6; + private static readonly _serializedATNSegment0: string = + "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\u0110\u0ACC\x04" + + "\x02\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04" + + "\x07\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r" + + "\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12" + + "\x04\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17\t\x17" + + "\x04\x18\t\x18\x04\x19\t\x19\x04\x1A\t\x1A\x04\x1B\t\x1B\x04\x1C\t\x1C" + + "\x04\x1D\t\x1D\x04\x1E\t\x1E\x04\x1F\t\x1F\x04 \t \x04!\t!\x04\"\t\"\x04" + + "#\t#\x04$\t$\x04%\t%\x04&\t&\x04\'\t\'\x04(\t(\x04)\t)\x04*\t*\x04+\t" + + "+\x04,\t,\x04-\t-\x04.\t.\x04/\t/\x040\t0\x041\t1\x042\t2\x043\t3\x04" + + "4\t4\x045\t5\x046\t6\x047\t7\x048\t8\x049\t9\x04:\t:\x04;\t;\x04<\t<\x04" + + "=\t=\x04>\t>\x04?\t?\x04@\t@\x04A\tA\x04B\tB\x04C\tC\x04D\tD\x04E\tE\x04" + + "F\tF\x04G\tG\x04H\tH\x04I\tI\x04J\tJ\x04K\tK\x04L\tL\x04M\tM\x04N\tN\x04" + + "O\tO\x04P\tP\x04Q\tQ\x04R\tR\x04S\tS\x04T\tT\x04U\tU\x04V\tV\x04W\tW\x04" + + "X\tX\x04Y\tY\x04Z\tZ\x04[\t[\x04\\\t\\\x04]\t]\x04^\t^\x04_\t_\x04`\t" + + "`\x04a\ta\x04b\tb\x04c\tc\x04d\td\x04e\te\x04f\tf\x04g\tg\x04h\th\x04" + + "i\ti\x04j\tj\x04k\tk\x04l\tl\x04m\tm\x04n\tn\x04o\to\x04p\tp\x04q\tq\x04" + + "r\tr\x04s\ts\x04t\tt\x04u\tu\x04v\tv\x04w\tw\x04x\tx\x04y\ty\x04z\tz\x04" + + "{\t{\x04|\t|\x04}\t}\x04~\t~\x04\x7F\t\x7F\x04\x80\t\x80\x04\x81\t\x81" + + "\x04\x82\t\x82\x04\x83\t\x83\x04\x84\t\x84\x04\x85\t\x85\x04\x86\t\x86" + + "\x04\x87\t\x87\x04\x88\t\x88\x04\x89\t\x89\x04\x8A\t\x8A\x04\x8B\t\x8B" + + "\x04\x8C\t\x8C\x04\x8D\t\x8D\x04\x8E\t\x8E\x04\x8F\t\x8F\x04\x90\t\x90" + + "\x04\x91\t\x91\x04\x92\t\x92\x04\x93\t\x93\x04\x94\t\x94\x04\x95\t\x95" + + "\x04\x96\t\x96\x04\x97\t\x97\x04\x98\t\x98\x04\x99\t\x99\x04\x9A\t\x9A" + + "\x04\x9B\t\x9B\x04\x9C\t\x9C\x04\x9D\t\x9D\x04\x9E\t\x9E\x04\x9F\t\x9F" + + "\x04\xA0\t\xA0\x04\xA1\t\xA1\x04\xA2\t\xA2\x04\xA3\t\xA3\x04\xA4\t\xA4" + + "\x04\xA5\t\xA5\x04\xA6\t\xA6\x04\xA7\t\xA7\x04\xA8\t\xA8\x04\xA9\t\xA9" + + "\x04\xAA\t\xAA\x04\xAB\t\xAB\x04\xAC\t\xAC\x04\xAD\t\xAD\x04\xAE\t\xAE" + + "\x04\xAF\t\xAF\x04\xB0\t\xB0\x04\xB1\t\xB1\x04\xB2\t\xB2\x04\xB3\t\xB3" + + "\x04\xB4\t\xB4\x04\xB5\t\xB5\x03\x02\x03\x02\x05\x02\u016D\n\x02\x07\x02" + + "\u016F\n\x02\f\x02\x0E\x02\u0172\v\x02\x03\x02\x03\x02\x03\x03\x03\x03" + + "\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03" + + "\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03" + + "\x03\x03\x03\x03\x05\x03\u018C\n\x03\x03\x04\x03\x04\x03\x04\x03\x05\x03" + + "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x05\x05\u0199\n\x05" + + "\x03\x06\x03\x06\x05\x06\u019D\n\x06\x03\x06\x03\x06\x05\x06\u01A1\n\x06" + + "\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x07\x06\u01A8\n\x06\f\x06\x0E" + + "\x06\u01AB\v\x06\x03\x06\x03\x06\x05\x06\u01AF\n\x06\x03\x06\x03\x06\x05" + + "\x06\u01B3\n\x06\x03\x06\x03\x06\x03\x06\x03\x06\x05\x06\u01B9\n\x06\x05" + + "\x06\u01BB\n\x06\x03\x06\x03\x06\x03\x06\x05\x06\u01C0\n\x06\x03\x07\x03" + + "\x07\x05\x07\u01C4\n\x07\x03\x07\x03\x07\x05\x07\u01C8\n\x07\x03\x07\x03" + + "\x07\x03\x07\x03\x07\x03\x07\x05\x07\u01CF\n\x07\x03\x07\x03\x07\x03\x07" + + "\x05\x07\u01D4\n\x07\x03\x07\x03\x07\x03\b\x03\b\x05\b\u01DA\n\b\x03\b" + + "\x03\b\x05\b\u01DE\n\b\x03\b\x03\b\x03\b\x03\b\x03\b\x07\b\u01E5\n\b\f" + + "\b\x0E\b\u01E8\v\b\x03\b\x03\b\x03\b\x03\b\x05\b\u01EE\n\b\x03\b\x03\b" + + "\x05\b\u01F2\n\b\x03\b\x03\b\x03\b\x05\b\u01F7\n\b\x05\b\u01F9\n\b\x03" + + "\b\x03\b\x03\b\x05\b\u01FE\n\b\x03\b\x03\b\x05\b\u0202\n\b\x03\b\x03\b" + + "\x03\b\x03\b\x03\b\x05\b\u0209\n\b\x03\b\x03\b\x05\b\u020D\n\b\x03\t\x03" + + "\t\x03\t\x05\t\u0212\n\t\x03\t\x03\t\x05\t\u0216\n\t\x03\t\x03\t\x05\t" + + "\u021A\n\t\x03\t\x03\t\x05\t\u021E\n\t\x03\t\x03\t\x03\t\x03\n\x03\n\x03" + + "\n\x05\n\u0226\n\n\x03\n\x03\n\x03\n\x05\n\u022B\n\n\x03\n\x03\n\x05\n" + + "\u022F\n\n\x03\v\x03\v\x03\v\x03\v\x03\f\x03\f\x05\f\u0237\n\f\x03\f\x03" + + "\f\x05\f\u023B\n\f\x03\f\x03\f\x03\f\x03\f\x03\f\x07\f\u0242\n\f\f\f\x0E" + + "\f\u0245\v\f\x05\f\u0247\n\f\x03\f\x05\f\u024A\n\f\x03\f\x03\f\x03\f\x03" + + "\f\x05\f\u0250\n\f\x03\f\x03\f\x03\f\x03\f\x03\f\x05\f\u0257\n\f\x03\f" + + "\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x05\f\u0262\n\f\x03\f" + + "\x03\f\x03\f\x05\f\u0267\n\f\x03\f\x03\f\x03\f\x05\f\u026C\n\f\x03\f\x03" + + "\f\x03\f\x05\f\u0271\n\f\x03\r\x03\r\x03\r\x05\r\u0276\n\r\x03\r\x03\r" + + "\x03\r\x03\r\x03\r\x07\r\u027D\n\r\f\r\x0E\r\u0280\v\r\x05\r\u0282\n\r" + + "\x03\r\x05\r\u0285\n\r\x03\r\x03\r\x05\r\u0289\n\r\x03\r\x03\r\x03\r\x03" + + "\r\x03\r\x03\r\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E" + + "\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E" + + "\x03\x0E\x03\x0E\x05\x0E\u02A3\n\x0E\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x03" + + "\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03" + + "\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03" + + "\x10\x03\x10\x05\x10\u02BD\n\x10\x03\x10\x03\x10\x03\x11\x03\x11\x03\x11" + + "\x03\x11\x03\x11\x05\x11\u02C6\n\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03" + + "\x11\x03\x11\x03\x11\x03\x11\x05\x11\u02D0\n\x11\x03\x11\x05\x11\u02D3" + + "\n\x11\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x13" + + "\x03\x13\x03\x13\x03\x13\x03\x13\x05\x13\u02E1\n\x13\x03\x13\x03\x13\x03" + + "\x14\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14\x03\x15\x03" + + "\x15\x03\x15\x03\x15\x03\x15\x03\x15\x05\x15\u02F3\n\x15\x05\x15\u02F5" + + "\n\x15\x03\x15\x03\x15\x03\x15\x03\x15\x03\x15\x07\x15\u02FC\n\x15\f\x15" + + "\x0E\x15\u02FF\v\x15\x03\x15\x03\x15\x03\x16\x03\x16\x03\x16\x03\x16\x03" + + "\x16\x03\x16\x05\x16\u0309\n\x16\x03\x16\x03\x16\x03\x17\x03\x17\x03\x17" + + "\x03\x17\x03\x17\x05\x17\u0312\n\x17\x03\x17\x03\x17\x03\x17\x03\x17\x03" + + "\x17\x05\x17\u0319\n\x17\x03\x17\x03\x17\x05\x17\u031D\n\x17\x03\x18\x03" + + "\x18\x03\x18\x03\x18\x03\x18\x05\x18\u0324\n\x18\x03\x18\x03\x18\x03\x18" + + "\x03\x18\x05\x18\u032A\n\x18\x03\x18\x05\x18\u032D\n\x18\x03\x18\x03\x18" + + "\x03\x18\x05\x18\u0332\n\x18\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19\x05" + + "\x19\u0339\n\x19\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19" + + "\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19\x05\x19\u0347\n\x19\x03\x1A\x03" + + "\x1A\x03\x1A\x03\x1A\x03\x1A\x03\x1A\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03" + + "\x1B\x05\x1B\u0354\n\x1B\x03\x1B\x03\x1B\x03\x1B\x05\x1B\u0359\n\x1B\x03" + + "\x1B\x03\x1B\x03\x1B\x05\x1B\u035E\n\x1B\x03\x1C\x03\x1C\x03\x1C\x03\x1C" + + "\x05\x1C\u0364\n\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1D\x03\x1D\x03\x1D\x03" + + "\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03" + + "\x1E\x03\x1E\x03\x1E\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x03" + + "\x1F\x03 \x03 \x03 \x03 \x03 \x03 \x03 \x03!\x03!\x05!\u0388\n!\x03!\x05" + + "!\u038B\n!\x03!\x03!\x03\"\x03\"\x05\"\u0391\n\"\x03\"\x05\"\u0394\n\"" + + "\x03\"\x03\"\x03#\x03#\x05#\u039A\n#\x03$\x03$\x03$\x03$\x05$\u03A0\n" + + "$\x03$\x03$\x03$\x03$\x03$\x03$\x03$\x03$\x03$\x03$\x05$\u03AC\n$\x05" + + "$\u03AE\n$\x03%\x03%\x03%\x03%\x03%\x03%\x05%\u03B6\n%\x03&\x03&\x03&" + + "\x03&\x03&\x03&\x05&\u03BE\n&\x03\'\x03\'\x03\'\x05\'\u03C3\n\'\x03\'" + + "\x03\'\x05\'\u03C7\n\'\x03(\x03(\x03(\x05(\u03CC\n(\x03(\x03(\x03)\x03" + + ")\x03)\x05)\u03D3\n)\x03)\x03)\x05)\u03D7\n)\x03*\x03*\x05*\u03DB\n*\x03" + + "*\x03*\x03*\x03*\x05*\u03E1\n*\x03+\x03+\x05+\u03E5\n+\x03+\x03+\x05+" + + "\u03E9\n+\x03+\x03+\x03+\x03+\x03+\x07+\u03F0\n+\f+\x0E+\u03F3\v+\x05" + + "+\u03F5\n+\x03+\x05+\u03F8\n+\x03,\x03,\x03,\x03,\x03-\x03-\x05-\u0400" + + "\n-\x03.\x03.\x03.\x03.\x03.\x03.\x03.\x03/\x03/\x03/\x03/\x03/\x05/\u040E" + + "\n/\x03/\x03/\x03/\x030\x030\x050\u0415\n0\x031\x031\x031\x031\x031\x03" + + "1\x031\x032\x032\x032\x032\x052\u0422\n2\x032\x032\x032\x032\x052\u0428" + + "\n2\x032\x032\x032\x052\u042D\n2\x032\x052\u0430\n2\x033\x053\u0433\n" + + "3\x033\x033\x033\x053\u0438\n3\x033\x033\x053\u043C\n3\x033\x033\x033" + + "\x033\x033\x073\u0443\n3\f3\x0E3\u0446\v3\x033\x033\x053\u044A\n3\x03" + + "3\x033\x034\x034\x054\u0450\n4\x035\x035\x055\u0454\n5\x035\x035\x035" + + "\x055\u0459\n5\x036\x036\x036\x056\u045E\n6\x036\x056\u0461\n6\x036\x03" + + "6\x036\x036\x076\u0467\n6\f6\x0E6\u046A\v6\x056\u046C\n6\x036\x036\x05" + + "6\u0470\n6\x037\x037\x037\x037\x037\x037\x037\x037\x077\u047A\n7\f7\x0E" + + "7\u047D\v7\x057\u047F\n7\x037\x037\x057\u0483\n7\x038\x038\x038\x058\u0488" + + "\n8\x038\x038\x058\u048C\n8\x038\x038\x039\x039\x039\x039\x039\x039\x03" + + "9\x039\x039\x039\x039\x039\x059\u049C\n9\x03:\x03:\x03:\x05:\u04A1\n:" + + "\x03:\x03:\x03:\x07:\u04A6\n:\f:\x0E:\u04A9\v:\x05:\u04AB\n:\x03;\x03" + + ";\x03;\x03;\x05;\u04B1\n;\x03;\x05;\u04B4\n;\x03;\x03;\x03;\x07;\u04B9" + + "\n;\f;\x0E;\u04BC\v;\x05;\u04BE\n;\x03<\x03<\x05<\u04C2\n<\x03<\x03<\x03" + + "<\x05<\u04C7\n<\x03<\x05<\u04CA\n<\x03<\x03<\x03<\x07<\u04CF\n<\f<\x0E" + + "<\u04D2\v<\x05<\u04D4\n<\x03=\x03=\x03=\x03=\x03=\x03>\x03>\x03>\x03>" + + "\x03>\x03?\x03?\x03?\x03?\x03?\x03@\x03@\x03@\x03@\x03@\x03A\x03A\x05" + + "A\u04EC\nA\x03A\x03A\x03A\x03B\x03B\x03B\x03B\x03B\x03B\x03B\x03B\x03" + + "B\x05B\u04FA\nB\x03B\x03B\x05B\u04FE\nB\x03C\x03C\x05C\u0502\nC\x03C\x03" + + "C\x03D\x03D\x03D\x03D\x03D\x03D\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03" + + "E\x03E\x03E\x05E\u0516\nE\x05E\u0518\nE\x05E\u051A\nE\x03F\x03F\x03F\x03" + + "F\x03F\x03F\x03F\x05F\u0523\nF\x05F\u0525\nF\x03G\x03G\x03G\x03G\x03G" + + "\x03G\x03G\x05G\u052E\nG\x05G\u0530\nG\x03H\x03H\x03H\x03H\x03H\x03H\x03" + + "H\x05H\u0539\nH\x05H\u053B\nH\x03I\x03I\x03I\x05I\u0540\nI\x03J\x03J\x03" + + "J\x03J\x03J\x03J\x03J\x05J\u0549\nJ\x03K\x03K\x03K\x03K\x03K\x03K\x03" + + "K\x05K\u0552\nK\x03L\x03L\x03L\x03L\x03L\x03L\x03L\x05L\u055B\nL\x03M" + + "\x03M\x03M\x03N\x03N\x03N\x03N\x03N\x03N\x05N\u0566\nN\x03O\x03O\x03O" + + "\x03O\x05O\u056C\nO\x03O\x03O\x03O\x05O\u0571\nO\x03O\x05O\u0574\nO\x03" + + "O\x03O\x03P\x03P\x03P\x03P\x03Q\x03Q\x03Q\x03Q\x03Q\x05Q\u0581\nQ\x03" + + "Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03Q\x05Q\u058B\nQ\x03Q\x03Q\x05Q\u058F" + + "\nQ\x03R\x03R\x03R\x05R\u0594\nR\x03S\x03S\x03S\x03S\x03S\x03S\x03S\x07" + + "S\u059D\nS\fS\x0ES\u05A0\vS\x03S\x03S\x05S\u05A4\nS\x03T\x03T\x03T\x03" + + "U\x03U\x03U\x03U\x03V\x03V\x03V\x03W\x03W\x03W\x03W\x03X\x03X\x03Y\x03" + + "Y\x03Z\x03Z\x03[\x03[\x03\\\x03\\\x03]\x03]\x03^\x03^\x03^\x07^\u05C3" + + "\n^\f^\x0E^\u05C6\v^\x03_\x03_\x03_\x07_\u05CB\n_\f_\x0E_\u05CE\v_\x03" + + "`\x03`\x03a\x03a\x03b\x03b\x05b\u05D6\nb\x03c\x03c\x03c\x05c\u05DB\nc" + + "\x03c\x03c\x05c\u05DF\nc\x03c\x03c\x03c\x05c\u05E4\nc\x03c\x03c\x03c\x05" + + "c\u05E9\nc\x03c\x03c\x03c\x05c\u05EE\nc\x03c\x03c\x05c\u05F2\nc\x03c\x03" + + "c\x03c\x03c\x03c\x03c\x03c\x05c\u05FB\nc\x03c\x05c\u05FE\nc\x03c\x03c" + + "\x05c\u0602\nc\x03d\x03d\x03d\x07d\u0607\nd\fd\x0Ed\u060A\vd\x03e\x03" + + "e\x03e\x03e\x03f\x03f\x03f\x03f\x05f\u0614\nf\x03f\x03f\x03f\x03f\x05" + + "f\u061A\nf\x07f\u061C\nf\ff\x0Ef\u061F\vf\x03f\x03f\x03g\x05g\u0624\n" + + "g\x03g\x03g\x03h\x03h\x03h\x03h\x07h\u062C\nh\fh\x0Eh\u062F\vh\x03i\x03" + + "i\x03i\x03i\x05i\u0635\ni\x03i\x03i\x03i\x05i\u063A\ni\x03i\x03i\x03i" + + "\x05i\u063F\ni\x03i\x03i\x03i\x05i\u0644\ni\x03i\x03i\x07i\u0648\ni\f" + + "i\x0Ei\u064B\vi\x05i\u064D\ni\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x05j" + + "\u0656\nj\x03j\x05j\u0659\nj\x03j\x05j\u065C\nj\x03k\x03k\x03k\x03k\x05" + + "k\u0662\nk\x03l\x03l\x03m\x03m\x03m\x03m\x07m\u066A\nm\fm\x0Em\u066D\v" + + "m\x05m\u066F\nm\x03m\x03m\x05m\u0673\nm\x03m\x03m\x05m\u0677\nm\x03n\x03" + + "n\x03n\x03n\x05n\u067D\nn\x03n\x03n\x07n\u0681\nn\fn\x0En\u0684\vn\x05" + + "n\u0686\nn\x03o\x03o\x03o\x03o\x05o\u068C\no\x03o\x03o\x07o\u0690\no\f" + + "o\x0Eo\u0693\vo\x05o\u0695\no\x03p\x05p\u0698\np\x03p\x03p\x05p\u069C" + + "\np\x03q\x03q\x03q\x03q\x03q\x03q\x03q\x03q\x05q\u06A6\nq\x03r\x03r\x03" + + "s\x03s\x03t\x03t\x03t\x07t\u06AF\nt\ft\x0Et\u06B2\vt\x03t\x03t\x05t\u06B6" + + "\nt\x03t\x05t\u06B9\nt\x03u\x03u\x05u\u06BD\nu\x03u\x03u\x03u\x03v\x03" + + "v\x05v\u06C4\nv\x03v\x03v\x03v\x03v\x03v\x03v\x07v\u06CC\nv\fv\x0Ev\u06CF" + + "\vv\x03v\x03v\x03w\x03w\x03w\x03w\x03w\x03w\x03w\x05w\u06DA\nw\x03w\x03" + + "w\x03w\x03w\x05w\u06E0\nw\x05w\u06E2\nw\x03x\x03x\x03x\x03x\x03x\x03x" + + "\x03x\x05x\u06EB\nx\x03x\x05x\u06EE\nx\x03y\x03y\x03y\x03y\x03y\x05y\u06F5" + + "\ny\x03z\x03z\x03z\x03z\x03z\x03z\x03z\x03z\x05z\u06FF\nz\x03{\x03{\x03" + + "{\x03{\x05{\u0705\n{\x03|\x03|\x03|\x03|\x07|\u070B\n|\f|\x0E|\u070E\v" + + "|\x03|\x03|\x03}\x03}\x03}\x03}\x07}\u0716\n}\f}\x0E}\u0719\v}\x03}\x03" + + "}\x03~\x03~\x03~\x07~\u0720\n~\f~\x0E~\u0723\v~\x03\x7F\x03\x7F\x03\x7F" + + "\x03\x7F\x03\x7F\x03\x7F\x03\x7F\x03\x7F\x05\x7F\u072D\n\x7F\x05\x7F\u072F" + + "\n\x7F\x03\x7F\x03\x7F\x03\x7F\x03\x7F\x05\x7F\u0735\n\x7F\x03\x80\x03" + + "\x80\x03\x80\x05\x80\u073A\n\x80\x03\x81\x03\x81\x03\x81\x03\x81\x03\x81" + + "\x03\x81\x07\x81\u0742\n\x81\f\x81\x0E\x81\u0745\v\x81\x05\x81\u0747\n" + + "\x81\x03\x81\x03\x81\x03\x81\x03\x81\x05\x81\u074D\n\x81\x05\x81\u074F" + + "\n\x81\x03\x82\x03\x82\x03\x82\x03\x82\x03\x82\x03\x82\x05\x82\u0757\n" + + "\x82\x03\x82\x03\x82\x03\x82\x03\x82\x05\x82\u075D\n\x82\x03\x82\x07\x82" + + "\u0760\n\x82\f\x82\x0E\x82\u0763\v\x82\x03\x83\x03\x83\x03\x83\x03\x83" + + "\x03\x83\x03\x83\x03\x83\x07\x83\u076C\n\x83\f\x83\x0E\x83\u076F\v\x83" + + "\x03\x83\x03\x83\x03\x83\x03\x83\x05\x83\u0775\n\x83\x03\x84\x03\x84\x05" + + "\x84\u0779\n\x84\x03\x84\x03\x84\x05\x84\u077D\n\x84\x03\x85\x03\x85\x05" + + "\x85\u0781\n\x85\x03\x85\x05\x85\u0784\n\x85\x03\x85\x03\x85\x03\x85\x07" + + "\x85\u0789\n\x85\f\x85\x0E\x85\u078C\v\x85\x03\x85\x03\x85\x03\x85\x03" + + "\x85\x07\x85\u0792\n\x85\f\x85\x0E\x85\u0795\v\x85\x05\x85\u0797\n\x85" + + "\x03\x85\x03\x85\x05\x85\u079B\n\x85\x03\x85\x03\x85\x03\x85\x05\x85\u07A0" + + "\n\x85\x03\x85\x03\x85\x05\x85\u07A4\n\x85\x03\x86\x05\x86\u07A7\n\x86" + + "\x03\x86\x03\x86\x03\x86\x07\x86\u07AC\n\x86\f\x86\x0E\x86\u07AF\v\x86" + + "\x03\x87\x03\x87\x03\x88\x03\x88\x03\x88\x03\x88\x07\x88\u07B7\n\x88\f" + + "\x88\x0E\x88\u07BA\v\x88\x05\x88\u07BC\n\x88\x03\x88\x03\x88\x05\x88\u07C0" + + "\n\x88\x03\x89\x03\x89\x05\x89\u07C4\n\x89\x03\x89\x03\x89\x03\x89\x03" + + "\x8A\x03\x8A\x03\x8B\x03\x8B\x05\x8B\u07CD\n\x8B\x03\x8B\x05\x8B\u07D0" + + "\n\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8B\x05\x8B\u07D7\n\x8B\x03" + + "\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03" + + "\x8C\x03\x8C\x03\x8C\x05\x8C\u07E5\n\x8C\x07\x8C\u07E7\n\x8C\f\x8C\x0E" + + "\x8C\u07EA\v\x8C\x03\x8D\x05\x8D\u07ED\n\x8D\x03\x8D\x03\x8D\x05\x8D\u07F1" + + "\n\x8D\x03\x8D\x03\x8D\x05\x8D\u07F5\n\x8D\x03\x8D\x03\x8D\x05\x8D\u07F9" + + "\n\x8D\x03\x8D\x03\x8D\x05\x8D\u07FD\n\x8D\x03\x8D\x03\x8D\x05\x8D\u0801" + + "\n\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D" + + "\x05\x8D\u080B\n\x8D\x03\x8E\x03\x8E\x03\x8E\x03\x8E\x03\x8E\x03\x8E\x03" + + "\x8E\x07\x8E\u0814\n\x8E\f\x8E\x0E\x8E\u0817\v\x8E\x03\x8E\x03\x8E\x05" + + "\x8E\u081B\n\x8E\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F" + + "\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x05\x8F\u0828\n\x8F\x05\x8F\u082A\n\x8F" + + "\x03\x90\x03\x90\x03\x91\x03\x91\x05\x91\u0830\n\x91\x03\x91\x03\x91\x05" + + "\x91\u0834\n\x91\x05\x91\u0836\n\x91\x03\x92\x03\x92\x03\x92\x03\x92\x07" + + "\x92\u083C\n\x92\f\x92\x0E\x92\u083F\v\x92\x03\x92\x03\x92\x03\x93\x03" + + "\x93\x03\x93\x03\x93\x07\x93\u0847\n\x93\f\x93\x0E\x93\u084A\v\x93\x03" + + "\x93\x03\x93\x03\x94\x03\x94\x05\x94\u0850\n\x94\x03\x94\x03\x94\x03\x94" + + "\x05\x94\u0855\n\x94\x03\x95\x03\x95\x03\x95\x03\x95\x03\x96\x03\x96\x03" + + "\x96\x03\x96\x03\x96\x07\x96\u0860\n\x96\f\x96\x0E\x96\u0863\v\x96\x03" + + "\x96\x03\x96\x03\x96\x05\x96\u0868\n\x96\x03\x97\x03\x97\x03\x97\x03\x97" + + "\x03\x98\x03\x98\x05\x98\u0870\n\x98\x03\x99\x03\x99\x03\x9A\x03\x9A\x03" + + "\x9A\x05\x9A\u0877\n\x9A\x03\x9A\x03\x9A\x05\x9A\u087B\n\x9A\x03\x9A\x03" + + "\x9A\x03\x9A\x03\x9A\x03\x9A\x03\x9A\x07\x9A\u0883\n\x9A\f\x9A\x0E\x9A" + + "\u0886\v\x9A\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x03" + + "\x9B\x05\x9B\u0890\n\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9B" + + "\x05\x9B\u0898\n\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x07\x9B\u089F" + + "\n\x9B\f\x9B\x0E\x9B\u08A2\v\x9B\x03\x9B\x03\x9B\x03\x9B\x05\x9B\u08A7" + + "\n\x9B\x03\x9B\x03\x9B\x03\x9B\x05\x9B\u08AC\n\x9B\x03\x9B\x03\x9B\x03" + + "\x9B\x03\x9B\x05\x9B\u08B2\n\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x05\x9B" + + "\u08B8\n\x9B\x03\x9B\x03\x9B\x03\x9B\x05\x9B\u08BD\n\x9B\x03\x9B\x03\x9B" + + "\x03\x9B\x05\x9B\u08C2\n\x9B\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x05\x9C\u08C8" + + "\n\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C" + + "\x03\x9C\x07\x9C\u08D3\n\x9C\f\x9C\x0E\x9C\u08D6\v\x9C\x03\x9D\x03\x9D" + + "\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D" + + "\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D" + + "\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x05\x9D\u08F0\n\x9D\x03\x9D\x03\x9D\x03" + + "\x9D\x03\x9D\x05\x9D\u08F6\n\x9D\x07\x9D\u08F8\n\x9D\f\x9D\x0E\x9D\u08FB" + + "\v\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x07\x9D" + + "\u0904\n\x9D\f\x9D\x0E\x9D\u0907\v\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D" + + "\x03\x9D\x03\x9D\x03\x9D\x05\x9D\u0910\n\x9D\x03\x9D\x05\x9D\u0913\n\x9D" + + "\x03\x9D\x03\x9D\x03\x9D"; + private static readonly _serializedATNSegment1: string = + "\x05\x9D\u0918\n\x9D\x03\x9D\x03\x9D\x03\x9D\x07\x9D\u091D\n\x9D\f\x9D" + + "\x0E\x9D\u0920\v\x9D\x05\x9D\u0922\n\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D" + + "\x03\x9D\x07\x9D\u0929\n\x9D\f\x9D\x0E\x9D\u092C\v\x9D\x05\x9D\u092E\n" + + "\x9D\x03\x9D\x03\x9D\x05\x9D\u0932\n\x9D\x03\x9D\x05\x9D\u0935\n\x9D\x03" + + "\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x07\x9D\u093F" + + "\n\x9D\f\x9D\x0E\x9D\u0942\v\x9D\x05\x9D\u0944\n\x9D\x03\x9D\x03\x9D\x03" + + "\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03" + + "\x9D\x03\x9D\x03\x9D\x03\x9D\x06\x9D\u0955\n\x9D\r\x9D\x0E\x9D\u0956\x03" + + "\x9D\x03\x9D\x05\x9D\u095B\n\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x06\x9D" + + "\u0961\n\x9D\r\x9D\x0E\x9D\u0962\x03\x9D\x03\x9D\x05\x9D\u0967\n\x9D\x03" + + "\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03" + + "\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03" + + "\x9D\x03\x9D\x03\x9D\x07\x9D\u097E\n\x9D\f\x9D\x0E\x9D\u0981\v\x9D\x05" + + "\x9D\u0983\n\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D" + + "\x05\x9D\u098C\n\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x05\x9D\u0992\n\x9D" + + "\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x05\x9D\u0998\n\x9D\x03\x9D\x03\x9D\x03" + + "\x9D\x03\x9D\x05\x9D\u099E\n\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D" + + "\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x05\x9D\u09A9\n\x9D\x03\x9D\x03\x9D\x03" + + "\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x05\x9D\u09B2\n\x9D\x03\x9D\x03\x9D" + + "\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D" + + "\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x07\x9D\u09C6" + + "\n\x9D\f\x9D\x0E\x9D\u09C9\v\x9D\x05\x9D\u09CB\n\x9D\x03\x9D\x05\x9D\u09CE" + + "\n\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D" + + "\x07\x9D\u09D8\n\x9D\f\x9D\x0E\x9D\u09DB\v\x9D\x03\x9E\x03\x9E\x03\x9E" + + "\x03\x9E\x05\x9E\u09E1\n\x9E\x05\x9E\u09E3\n\x9E\x03\x9F\x03\x9F\x03\xA0" + + "\x03\xA0\x03\xA1\x03\xA1\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03\xA2" + + "\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x05\xA2" + + "\u09F9\n\xA2\x03\xA3\x03\xA3\x03\xA4\x03\xA4\x03\xA5\x03\xA5\x03\xA5\x03" + + "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03" + + "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03" + + "\xA5\x03\xA5\x07\xA5\u0A16\n\xA5\f\xA5\x0E\xA5\u0A19\v\xA5\x03\xA5\x03" + + "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x07\xA5\u0A22\n\xA5\f\xA5" + + "\x0E\xA5\u0A25\v\xA5\x03\xA5\x03\xA5\x05\xA5\u0A29\n\xA5\x05\xA5\u0A2B" + + "\n\xA5\x03\xA5\x03\xA5\x07\xA5\u0A2F\n\xA5\f\xA5\x0E\xA5\u0A32\v\xA5\x03" + + "\xA6\x03\xA6\x05\xA6\u0A36\n\xA6\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x05\xA7" + + "\u0A3C\n\xA7\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA9\x03\xA9\x03" + + "\xA9\x03\xA9\x03\xA9\x03\xA9\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03" + + "\xAA\x03\xAA\x07\xAA\u0A50\n\xAA\f\xAA\x0E\xAA\u0A53\v\xAA\x05\xAA\u0A55" + + "\n\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x07\xAA\u0A5C\n\xAA\f\xAA" + + "\x0E\xAA\u0A5F\v\xAA\x05\xAA\u0A61\n\xAA\x03\xAA\x05\xAA\u0A64\n\xAA\x03" + + "\xAA\x03\xAA\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03" + + "\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x05" + + "\xAB\u0A78\n\xAB\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC" + + "\x03\xAC\x03\xAC\x05\xAC\u0A83\n\xAC\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03" + + "\xAD\x05\xAD\u0A8A\n\xAD\x03\xAE\x03\xAE\x03\xAE\x07\xAE\u0A8F\n\xAE\f" + + "\xAE\x0E\xAE\u0A92\v\xAE\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF" + + "\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x05\xAF\u0A9F\n\xAF\x05\xAF\u0AA1" + + "\n\xAF\x03\xB0\x03\xB0\x03\xB1\x03\xB1\x03\xB1\x07\xB1\u0AA8\n\xB1\f\xB1" + + "\x0E\xB1\u0AAB\v\xB1\x03\xB2\x03\xB2\x03\xB2\x03\xB2\x03\xB2\x03\xB2\x05" + + "\xB2\u0AB3\n\xB2\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x05\xB3\u0ABA" + + "\n\xB3\x03\xB4\x05\xB4\u0ABD\n\xB4\x03\xB4\x03\xB4\x05\xB4\u0AC1\n\xB4" + + "\x03\xB4\x03\xB4\x05\xB4\u0AC5\n\xB4\x03\xB4\x05\xB4\u0AC8\n\xB4\x03\xB5" + + "\x03\xB5\x03\xB5\f\u02FD\u059E\u0649\u066B\u0682\u0691\u06B0\u06CD\u0717" + + "\u08F9\x02\b\u0102\u0116\u0132\u0136\u0138\u0148\xB6\x02\x02\x04\x02\x06" + + "\x02\b\x02\n\x02\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02" + + "\x1A\x02\x1C\x02\x1E\x02 \x02\"\x02$\x02&\x02(\x02*\x02,\x02.\x020\x02" + + "2\x024\x026\x028\x02:\x02<\x02>\x02@\x02B\x02D\x02F\x02H\x02J\x02L\x02" + + "N\x02P\x02R\x02T\x02V\x02X\x02Z\x02\\\x02^\x02`\x02b\x02d\x02f\x02h\x02" + + "j\x02l\x02n\x02p\x02r\x02t\x02v\x02x\x02z\x02|\x02~\x02\x80\x02\x82\x02" + + "\x84\x02\x86\x02\x88\x02\x8A\x02\x8C\x02\x8E\x02\x90\x02\x92\x02\x94\x02" + + "\x96\x02\x98\x02\x9A\x02\x9C\x02\x9E\x02\xA0\x02\xA2\x02\xA4\x02\xA6\x02" + + "\xA8\x02\xAA\x02\xAC\x02\xAE\x02\xB0\x02\xB2\x02\xB4\x02\xB6\x02\xB8\x02" + + "\xBA\x02\xBC\x02\xBE\x02\xC0\x02\xC2\x02\xC4\x02\xC6\x02\xC8\x02\xCA\x02" + + "\xCC\x02\xCE\x02\xD0\x02\xD2\x02\xD4\x02\xD6\x02\xD8\x02\xDA\x02\xDC\x02" + + "\xDE\x02\xE0\x02\xE2\x02\xE4\x02\xE6\x02\xE8\x02\xEA\x02\xEC\x02\xEE\x02" + + "\xF0\x02\xF2\x02\xF4\x02\xF6\x02\xF8\x02\xFA\x02\xFC\x02\xFE\x02\u0100" + + "\x02\u0102\x02\u0104\x02\u0106\x02\u0108\x02\u010A\x02\u010C\x02\u010E" + + "\x02\u0110\x02\u0112\x02\u0114\x02\u0116\x02\u0118\x02\u011A\x02\u011C" + + "\x02\u011E\x02\u0120\x02\u0122\x02\u0124\x02\u0126\x02\u0128\x02\u012A" + + "\x02\u012C\x02\u012E\x02\u0130\x02\u0132\x02\u0134\x02\u0136\x02\u0138" + + "\x02\u013A\x02\u013C\x02\u013E\x02\u0140\x02\u0142\x02\u0144\x02\u0146" + + "\x02\u0148\x02\u014A\x02\u014C\x02\u014E\x02\u0150\x02\u0152\x02\u0154" + + "\x02\u0156\x02\u0158\x02\u015A\x02\u015C\x02\u015E\x02\u0160\x02\u0162" + + "\x02\u0164\x02\u0166\x02\u0168\x02\x02\x1E\x04\x0200\xAB\xAB\x04\x02\xA7" + + "\xA7\xCE\xCE\x04\x02\xB1\xB1\xCC\xCC\x04\x02GGRR\x04\x02\x1D\x1D\xA0\xA0" + + "\x04\x02ii\x91\x91\x04\x0211\xAC\xAC\x04\x02\x05\x05\x0E\x0E\x05\x02Y" + + "Y\xA7\xA7\xCE\xCE\x04\x02\xB3\xB3\xD2\xD2\x03\x02\xE4\xE7\x04\x02\x94" + + "\x94\xDC\xE0\x04\x02CCaa\x04\x02BB\xCA\xCA\x04\x02\f\f99\x04\x02MMpp\x04" + + "\x02\x04\x04;;\x04\x02\x10\x10\xBB\xBB\x03\x02\xEE\xEF\x03\x02\xF0\xF2" + + "\x03\x02\xE8\xED\x05\x02\x04\x04\b\b\xB6\xB6\x04\x02HH\xC4\xC4\x07\x02" + + "23]^{~\xAD\xAE\xDA\xDB\x03\x02\x80\x83\x04\x02OO\x96\x96\x06\x0200\xB3" + + "\xB3\xBE\xBE\xD2\xD21\x02\x03\x04\b\b\n\n\f\r\x10\x10\x1D\x1D\"$))/35" + + "599CCEELMOOQQWX]]__aaggpqttz{}}\x80\x83\x87\x88\x8A\x8A\x8D\x8D\x90\x90" + + "\x92\x96\x99\x9B\x9D\xA0\xA2\xA2\xA7\xAE\xB1\xB1\xB4\xB4\xB6\xB7\xBA\xBB" + + "\xBF\xC0\xC3\xC3\xC5\xC6\xC9\xC9\xCD\xCE\xD5\xD6\xDA\xDA\xDC\xE0\x02\u0C0F" + + "\x02\u0170\x03\x02\x02\x02\x04\u018B\x03\x02\x02\x02\x06\u018D\x03\x02" + + "\x02\x02\b\u0198\x03\x02\x02\x02\n\u019A\x03\x02\x02\x02\f\u01C1\x03\x02" + + "\x02\x02\x0E\u01D7\x03\x02\x02\x02\x10\u020E\x03\x02\x02\x02\x12\u0222" + + "\x03\x02\x02\x02\x14\u0230\x03\x02\x02\x02\x16\u0234\x03\x02\x02\x02\x18" + + "\u0272\x03\x02\x02\x02\x1A\u02A2\x03\x02\x02\x02\x1C\u02A4\x03\x02\x02" + + "\x02\x1E\u02AC\x03\x02\x02\x02 \u02C0\x03\x02\x02\x02\"\u02D4\x03\x02" + + "\x02\x02$\u02DB\x03\x02\x02\x02&\u02E4\x03\x02\x02\x02(\u02EC\x03\x02" + + "\x02\x02*\u0302\x03\x02\x02\x02,\u030C\x03\x02\x02\x02.\u031E\x03\x02" + + "\x02\x020\u0333\x03\x02\x02\x022\u0348\x03\x02\x02\x024\u034E\x03\x02" + + "\x02\x026\u035F\x03\x02\x02\x028\u0368\x03\x02\x02\x02:\u036F\x03\x02" + + "\x02\x02<\u0377\x03\x02\x02\x02>\u037E\x03\x02\x02\x02@\u0385\x03\x02" + + "\x02\x02B\u038E\x03\x02\x02\x02D\u0399\x03\x02\x02\x02F\u039B\x03\x02" + + "\x02\x02H\u03AF\x03\x02\x02\x02J\u03BD\x03\x02\x02\x02L\u03BF\x03\x02" + + "\x02\x02N\u03C8\x03\x02\x02\x02P\u03CF\x03\x02\x02\x02R\u03D8\x03\x02" + + "\x02\x02T\u03E2\x03\x02\x02\x02V\u03F9\x03\x02\x02\x02X\u03FF\x03\x02" + + "\x02\x02Z\u0401\x03\x02\x02\x02\\\u0408\x03\x02\x02\x02^\u0414\x03\x02" + + "\x02\x02`\u0416\x03\x02\x02\x02b\u041D\x03\x02\x02\x02d\u0432\x03\x02" + + "\x02\x02f\u044F\x03\x02\x02\x02h\u0451\x03\x02\x02\x02j\u045A\x03\x02" + + "\x02\x02l\u0471\x03\x02\x02\x02n\u0484\x03\x02\x02\x02p\u049B\x03\x02" + + "\x02\x02r\u049D\x03\x02\x02\x02t\u04AC\x03\x02\x02\x02v\u04BF\x03\x02" + + "\x02\x02x\u04D5\x03\x02\x02\x02z\u04DA\x03\x02\x02\x02|\u04DF\x03\x02" + + "\x02\x02~\u04E4\x03\x02\x02\x02\x80\u04E9\x03\x02\x02\x02\x82\u04F0\x03" + + "\x02\x02\x02\x84\u04FF\x03\x02\x02\x02\x86\u0505\x03\x02\x02\x02\x88\u0519" + + "\x03\x02\x02\x02\x8A\u051B\x03\x02\x02\x02\x8C\u0526\x03\x02\x02\x02\x8E" + + "\u0531\x03\x02\x02\x02\x90\u053F\x03\x02\x02\x02\x92\u0541\x03\x02\x02" + + "\x02\x94\u054A\x03\x02\x02\x02\x96\u0553\x03\x02\x02\x02\x98\u055C\x03" + + "\x02\x02\x02\x9A\u055F\x03\x02\x02\x02\x9C\u0567\x03\x02\x02\x02\x9E\u0577" + + "\x03\x02\x02\x02\xA0\u057B\x03\x02\x02\x02\xA2\u0593\x03\x02\x02\x02\xA4" + + "\u0595\x03\x02\x02\x02\xA6\u05A5\x03\x02\x02\x02\xA8\u05A8\x03\x02\x02" + + "\x02\xAA\u05AC\x03\x02\x02\x02\xAC\u05AF\x03\x02\x02\x02\xAE\u05B3\x03" + + "\x02\x02\x02\xB0\u05B5\x03\x02\x02\x02\xB2\u05B7\x03\x02\x02\x02\xB4\u05B9" + + "\x03\x02\x02\x02\xB6\u05BB\x03\x02\x02\x02\xB8\u05BD\x03\x02\x02\x02\xBA" + + "\u05BF\x03\x02\x02\x02\xBC\u05C7\x03\x02\x02\x02\xBE\u05CF\x03\x02\x02" + + "\x02\xC0\u05D1\x03\x02\x02\x02\xC2\u05D5\x03\x02\x02\x02\xC4\u05DA\x03" + + "\x02\x02\x02\xC6\u0603\x03\x02\x02\x02\xC8\u060B\x03\x02\x02\x02\xCA\u060F" + + "\x03\x02\x02\x02\xCC\u0623\x03\x02\x02\x02\xCE\u0627\x03\x02\x02\x02\xD0" + + "\u0630\x03\x02\x02\x02\xD2\u064E\x03\x02\x02\x02\xD4\u065D\x03\x02\x02" + + "\x02\xD6\u0663\x03\x02\x02\x02\xD8\u0665\x03\x02\x02\x02\xDA\u0678\x03" + + "\x02\x02\x02\xDC\u0687\x03\x02\x02\x02\xDE\u069B\x03\x02\x02\x02\xE0\u06A5" + + "\x03\x02\x02\x02\xE2\u06A7\x03\x02\x02\x02\xE4\u06A9\x03\x02\x02\x02\xE6" + + "\u06B8\x03\x02\x02\x02\xE8\u06BA\x03\x02\x02\x02\xEA\u06C1\x03\x02\x02" + + "\x02\xEC\u06E1\x03\x02\x02\x02\xEE\u06ED\x03\x02\x02\x02\xF0\u06F4\x03" + + "\x02\x02\x02\xF2\u06FE\x03\x02\x02\x02\xF4\u0700\x03\x02\x02\x02\xF6\u0706" + + "\x03\x02\x02\x02\xF8\u0711\x03\x02\x02\x02\xFA\u071C\x03\x02\x02\x02\xFC" + + "\u0724\x03\x02\x02\x02\xFE\u0736\x03\x02\x02\x02\u0100\u073B\x03\x02\x02" + + "\x02\u0102\u0750\x03\x02\x02\x02\u0104\u0774\x03\x02\x02\x02\u0106\u0776" + + "\x03\x02\x02\x02\u0108\u077E\x03\x02\x02\x02\u010A\u07A6\x03\x02\x02\x02" + + "\u010C\u07B0\x03\x02\x02\x02\u010E\u07BF\x03\x02\x02\x02\u0110\u07C1\x03" + + "\x02\x02\x02\u0112\u07C8\x03\x02\x02\x02\u0114\u07D6\x03\x02\x02\x02\u0116" + + "\u07D8\x03\x02\x02\x02\u0118\u080A\x03\x02\x02\x02\u011A\u081A\x03\x02" + + "\x02\x02\u011C\u081C\x03\x02\x02\x02\u011E\u082B\x03\x02\x02\x02\u0120" + + "\u082D\x03\x02\x02\x02\u0122\u0837\x03\x02\x02\x02\u0124\u0842\x03\x02" + + "\x02\x02\u0126\u0854\x03\x02\x02\x02\u0128\u0856\x03\x02\x02\x02\u012A" + + "\u085A\x03\x02\x02\x02\u012C\u0869\x03\x02\x02\x02\u012E\u086F\x03\x02" + + "\x02\x02\u0130\u0871\x03\x02\x02\x02\u0132\u087A\x03\x02\x02\x02\u0134" + + "\u08C1\x03\x02\x02\x02\u0136\u08C7\x03\x02\x02\x02\u0138\u09CD\x03\x02" + + "\x02\x02\u013A\u09E2\x03\x02\x02\x02\u013C\u09E4\x03\x02\x02\x02\u013E" + + "\u09E6\x03\x02\x02\x02\u0140\u09E8\x03\x02\x02\x02\u0142\u09F8\x03\x02" + + "\x02\x02\u0144\u09FA\x03\x02\x02\x02\u0146\u09FC\x03\x02\x02\x02\u0148" + + "\u0A2A\x03\x02\x02\x02\u014A\u0A35\x03\x02\x02\x02\u014C\u0A3B\x03\x02" + + "\x02\x02\u014E\u0A3D\x03\x02\x02\x02\u0150\u0A42\x03\x02\x02\x02\u0152" + + "\u0A48\x03\x02\x02\x02\u0154\u0A77\x03\x02\x02\x02\u0156\u0A82\x03\x02" + + "\x02\x02\u0158\u0A89\x03\x02\x02\x02\u015A\u0A8B\x03\x02\x02\x02\u015C" + + "\u0AA0\x03\x02\x02\x02\u015E\u0AA2\x03\x02\x02\x02\u0160\u0AA4\x03\x02" + + "\x02\x02\u0162\u0AB2\x03\x02\x02\x02\u0164\u0AB9\x03\x02\x02\x02\u0166" + + "\u0AC7\x03\x02\x02\x02\u0168\u0AC9\x03\x02\x02\x02\u016A\u016C\x05\x04" + + "\x03\x02\u016B\u016D\x07\xF5\x02\x02\u016C\u016B\x03\x02\x02\x02\u016C" + + "\u016D\x03\x02\x02\x02\u016D\u016F\x03\x02\x02\x02\u016E\u016A\x03\x02" + + "\x02\x02\u016F\u0172\x03\x02\x02\x02\u0170\u016E\x03\x02\x02\x02\u0170" + + "\u0171\x03\x02\x02\x02\u0171\u0173\x03\x02\x02\x02\u0172\u0170\x03\x02" + + "\x02\x02\u0173\u0174\x07\x02\x02\x03\u0174\x03\x03\x02\x02\x02\u0175\u018C" + + "\x05\xCCg\x02\u0176\u018C\x05\x06\x04\x02\u0177\u018C\x05\b\x05\x02\u0178" + + "\u018C\x05\x1A\x0E\x02\u0179\u018C\x05@!\x02\u017A\u018C\x05B\"\x02\u017B" + + "\u018C\x05D#\x02\u017C\u018C\x05J&\x02\u017D\u018C\x05X-\x02\u017E\u018C" + + "\x05^0\x02\u017F\u018C\x05d3\x02\u0180\u018C\x05f4\x02\u0181\u018C\x05" + + "l7\x02\u0182\u018C\x05n8\x02\u0183\u018C\x05p9\x02\u0184\u018C\x05\x90" + + "I\x02\u0185\u018C\x05\x98M\x02\u0186\u018C\x05\x9AN\x02\u0187\u018C\x05" + + "\x9CO\x02\u0188\u018C\x05\x9EP\x02\u0189\u018C\x05\xA0Q\x02\u018A\u018C" + + "\x05\xA2R\x02\u018B\u0175\x03\x02\x02\x02\u018B\u0176\x03\x02\x02\x02" + + "\u018B\u0177\x03\x02\x02\x02\u018B\u0178\x03\x02\x02\x02\u018B\u0179\x03" + + "\x02\x02\x02\u018B\u017A\x03\x02\x02\x02\u018B\u017B\x03\x02\x02\x02\u018B" + + "\u017C\x03\x02\x02\x02\u018B\u017D\x03\x02\x02\x02\u018B\u017E\x03\x02" + + "\x02\x02\u018B\u017F\x03\x02\x02\x02\u018B\u0180\x03\x02\x02\x02\u018B" + + "\u0181\x03\x02\x02\x02\u018B\u0182\x03\x02\x02\x02\u018B\u0183\x03\x02" + + "\x02\x02\u018B\u0184\x03\x02\x02\x02\u018B\u0185\x03\x02\x02\x02\u018B" + + "\u0186\x03\x02\x02\x02\u018B\u0187\x03\x02\x02\x02\u018B\u0188\x03\x02" + + "\x02\x02\u018B\u0189\x03\x02\x02\x02\u018B\u018A\x03\x02\x02\x02\u018C" + + "\x05\x03\x02\x02\x02\u018D\u018E\x07\xCD\x02\x02\u018E\u018F\x05\xB8]" + + "\x02\u018F\x07\x03\x02\x02\x02\u0190\u0199\x05\x12\n\x02\u0191\u0199\x05" + + "\x14\v\x02\u0192\u0199\x05\x16\f\x02\u0193\u0199\x05\x18\r\x02\u0194\u0199" + + "\x05\x10\t\x02\u0195\u0199\x05\x0E\b\x02\u0196\u0199\x05\f\x07\x02\u0197" + + "\u0199\x05\n\x06\x02\u0198\u0190\x03\x02\x02\x02\u0198\u0191\x03\x02\x02" + + "\x02\u0198\u0192\x03\x02\x02\x02\u0198\u0193\x03\x02\x02\x02\u0198\u0194" + + "\x03\x02\x02\x02\u0198\u0195\x03\x02\x02\x02\u0198\u0196\x03\x02\x02\x02" + + "\u0198\u0197\x03\x02\x02\x02\u0199\t\x03\x02\x02\x02\u019A\u019C\x07\'" + + "\x02\x02\u019B\u019D\x07\x15\x02\x02\u019C\u019B\x03\x02\x02\x02\u019C" + + "\u019D\x03\x02\x02\x02\u019D\u019E\x03\x02\x02\x02\u019E\u01A0\x07\xBE" + + "\x02\x02\u019F\u01A1\x05\xACW\x02\u01A0\u019F\x03\x02\x02\x02\u01A0\u01A1" + + "\x03\x02\x02\x02\u01A1\u01A2\x03\x02\x02\x02\u01A2\u01B2\x05\xAEX\x02" + + "\u01A3\u01A4\x07\xF8\x02\x02\u01A4\u01A9\x05\xD4k\x02\u01A5\u01A6\x07" + + "\xF6\x02\x02\u01A6\u01A8\x05\xD4k\x02\u01A7\u01A5\x03\x02\x02\x02\u01A8" + + "\u01AB\x03\x02\x02\x02\u01A9\u01A7\x03\x02\x02\x02\u01A9\u01AA\x03\x02" + + "\x02\x02\u01AA\u01AE\x03\x02\x02\x02\u01AB\u01A9\x03\x02\x02\x02\u01AC" + + "\u01AD\x07\xF6\x02\x02\u01AD\u01AF\x05\xD0i\x02\u01AE\u01AC\x03\x02\x02" + + "\x02\u01AE\u01AF\x03\x02\x02\x02\u01AF\u01B0\x03\x02\x02\x02\u01B0\u01B1" + + "\x07\xF9\x02\x02\u01B1\u01B3\x03\x02\x02\x02\u01B2\u01A3\x03\x02\x02\x02" + + "\u01B2\u01B3\x03\x02\x02\x02\u01B3\u01BA\x03\x02\x02\x02\u01B4\u01B5\x07" + + "\x13\x02\x02\u01B5\u01B8\x07\x1C\x02\x02\u01B6\u01B9\x05\xF8}\x02\u01B7" + + "\u01B9\x05\u0124\x93\x02\u01B8\u01B6\x03\x02\x02\x02\u01B8\u01B7\x03\x02" + + "\x02\x02\u01B9\u01BB\x03\x02\x02\x02\u01BA\u01B4\x03\x02\x02\x02\u01BA" + + "\u01BB\x03\x02\x02\x02\u01BB\u01BC\x03\x02\x02\x02\u01BC\u01BF\x05\xC4" + + "c\x02\u01BD\u01BE\x07\v\x02\x02\u01BE\u01C0\x05\xCCg\x02\u01BF\u01BD\x03" + + "\x02\x02\x02\u01BF\u01C0\x03\x02\x02\x02\u01C0\v\x03\x02\x02\x02\u01C1" + + "\u01C3\x07\'\x02\x02\u01C2\u01C4\x07\x15\x02\x02\u01C3\u01C2\x03\x02\x02" + + "\x02\u01C3\u01C4\x03\x02\x02\x02\u01C4\u01C5\x03\x02\x02\x02\u01C5\u01C7" + + "\x07\xBE\x02\x02\u01C6\u01C8\x05\xACW\x02\u01C7\u01C6\x03\x02\x02\x02" + + "\u01C7\u01C8\x03\x02\x02\x02\u01C8\u01C9\x03\x02\x02\x02\u01C9\u01CA\x05" + + "\xAEX\x02\u01CA\u01CE\x07s\x02\x02\u01CB\u01CF\x05\xBA^\x02\u01CC\u01CD" + + "\x07\x94\x02\x02\u01CD\u01CF\x05\u013A\x9E\x02\u01CE\u01CB\x03\x02\x02" + + "\x02\u01CE\u01CC\x03\x02\x02\x02\u01CF\u01D3\x03\x02\x02\x02\u01D0\u01D1" + + "\x07\x13\x02\x02\u01D1\u01D2\x07\x1C\x02\x02\u01D2\u01D4\x05\xF8}\x02" + + "\u01D3\u01D0\x03\x02\x02\x02\u01D3\u01D4\x03\x02\x02\x02\u01D4\u01D5\x03" + + "\x02\x02\x02\u01D5\u01D6\x05\xC4c\x02\u01D6\r\x03\x02\x02\x02\u01D7\u01D9" + + "\x07\'\x02\x02\u01D8\u01DA\x07\x15\x02\x02\u01D9\u01D8\x03\x02\x02\x02" + + "\u01D9\u01DA\x03\x02\x02\x02\u01DA\u01DB\x03\x02\x02\x02\u01DB\u01DD\x07" + + "\xBE\x02\x02\u01DC\u01DE\x05\xACW\x02\u01DD\u01DC\x03\x02\x02\x02\u01DD" + + "\u01DE\x03\x02\x02\x02\u01DE\u01DF\x03\x02\x02\x02\u01DF\u01F1\x05\xAE" + + "X\x02\u01E0\u01E1\x07\xF8\x02\x02\u01E1\u01E6\x05\xD6l\x02\u01E2\u01E3" + + "\x07\xF6\x02\x02\u01E3\u01E5\x05\xD6l\x02\u01E4\u01E2\x03\x02\x02\x02" + + "\u01E5\u01E8\x03\x02\x02\x02\u01E6\u01E4\x03\x02\x02\x02\u01E6\u01E7\x03" + + "\x02\x02\x02\u01E7\u01ED\x03\x02\x02\x02\u01E8\u01E6\x03\x02\x02\x02\u01E9" + + "\u01EA\x07\xF6\x02\x02\u01EA\u01EB\x07\x97\x02\x02\u01EB\u01EC\x07n\x02" + + "\x02\u01EC\u01EE\x05\u0122\x92\x02\u01ED\u01E9\x03\x02\x02\x02\u01ED\u01EE" + + "\x03\x02\x02\x02\u01EE\u01EF\x03\x02\x02\x02\u01EF\u01F0\x07\xF9\x02\x02" + + "\u01F0\u01F2\x03\x02\x02\x02\u01F1\u01E0\x03\x02\x02\x02\u01F1\u01F2\x03" + + "\x02\x02\x02\u01F2\u01F8\x03\x02\x02\x02\u01F3\u01F4\x07\x97\x02\x02\u01F4" + + "\u01F6\x07n\x02\x02\u01F5\u01F7\x05\u0122\x92\x02\u01F6\u01F5\x03\x02" + + "\x02\x02\u01F6\u01F7\x03\x02\x02\x02\u01F7\u01F9\x03\x02\x02\x02\u01F8" + + "\u01F3\x03\x02\x02\x02\u01F8\u01F9\x03\x02\x02\x02\u01F9\u01FD\x03\x02" + + "\x02\x02\u01FA\u01FB\x07\x92\x02\x02\u01FB\u01FC\x07\x1C\x02\x02\u01FC" + + "\u01FE\x05\xE6t\x02\u01FD\u01FA\x03\x02\x02\x02\u01FD\u01FE\x03\x02\x02" + + "\x02\u01FE\u0201\x03\x02\x02\x02\u01FF\u0200\x07$\x02\x02\u0200\u0202" + + "\x05\u013A\x9E\x02\u0201\u01FF\x03\x02\x02\x02\u0201\u0202\x03\x02\x02" + + "\x02\u0202\u0203\x03\x02\x02\x02\u0203\u0204\x07\x19\x02\x02\u0204\u0205" + + "\x07\v\x02\x02\u0205\u0208\x07o\x02\x02\u0206\u0207\x07\x1B\x02\x02\u0207" + + "\u0209\x05\xF6|\x02\u0208\u0206\x03\x02\x02\x02\u0208\u0209\x03\x02\x02" + + "\x02\u0209\u020C\x03\x02\x02\x02\u020A\u020B\x07\v\x02\x02\u020B\u020D" + + "\x05\xCCg\x02\u020C\u020A\x03\x02\x02\x02\u020C\u020D\x03\x02\x02\x02" + + "\u020D\x0F\x03\x02\x02\x02\u020E\u020F\x07\'\x02\x02\u020F\u0211\x07\xD5" + + "\x02\x02\u0210\u0212\x05\xACW\x02\u0211\u0210\x03\x02\x02\x02\u0211\u0212" + + "\x03\x02\x02\x02\u0212\u0213\x03\x02\x02\x02\u0213\u0215\x05\xB2Z\x02" + + "\u0214\u0216\x05\xCAf\x02\u0215\u0214\x03\x02\x02\x02\u0215\u0216\x03" + + "\x02\x02\x02\u0216\u0219\x03\x02\x02\x02\u0217\u0218\x07$\x02\x02\u0218" + + "\u021A\x05\u013A\x9E\x02\u0219\u0217\x03\x02\x02\x02\u0219\u021A\x03\x02" + + "\x02\x02\u021A\u021D\x03\x02\x02\x02\u021B\u021C\x07\x1B\x02\x02\u021C" + + "\u021E\x05\xF6|\x02\u021D\u021B\x03\x02\x02\x02\u021D\u021E\x03\x02\x02" + + "\x02\u021E\u021F\x03\x02\x02\x02\u021F\u0220\x07\v\x02\x02\u0220\u0221" + + "\x05\xCCg\x02\u0221\x11\x03\x02\x02\x02\u0222\u0223\x07\'\x02\x02\u0223" + + "\u0225\t\x02\x02\x02\u0224\u0226\x05\xACW\x02\u0225\u0224\x03\x02\x02" + + "\x02\u0225\u0226\x03\x02\x02\x02\u0226\u0227\x03\x02\x02\x02\u0227\u022A" + + "\x05\xB0Y\x02\u0228\u0229\x07$\x02\x02\u0229\u022B\x05\u013A\x9E\x02\u022A" + + "\u0228\x03\x02\x02\x02\u022A\u022B\x03\x02\x02\x02\u022B\u022E\x03\x02" + + "\x02\x02\u022C\u022D\x07\x1A\x02\x02\u022D\u022F\x05\u013A\x9E\x02\u022E" + + "\u022C\x03\x02\x02\x02\u022E\u022F\x03\x02\x02\x02\u022F\x13\x03\x02\x02" + + "\x02\u0230\u0231\x07\'\x02\x02\u0231\u0232\x07\xA7\x02\x02\u0232\u0233" + + "\x05\u0164\xB3\x02\u0233\x15\x03\x02\x02\x02\u0234\u0236\x07\'\x02\x02" + + "\u0235\u0237\x07\x0E\x02\x02\u0236\u0235\x03\x02\x02\x02\u0236\u0237\x03" + + "\x02\x02\x02\u0237\u0238\x03\x02\x02\x02\u0238\u023A\x07V\x02\x02\u0239" + + "\u023B\x05\xACW\x02\u023A\u0239\x03\x02\x02\x02\u023A\u023B\x03\x02\x02" + + "\x02\u023B\u023C\x03\x02\x02\x02\u023C\u0249\x05\xB4[\x02\u023D\u0246" + + "\x07\xF8\x02\x02\u023E\u0243\x05\u0148\xA5\x02\u023F\u0240\x07\xF6\x02" + + "\x02\u0240\u0242\x05\u0148\xA5\x02\u0241\u023F\x03\x02\x02\x02\u0242\u0245" + + "\x03\x02\x02\x02\u0243\u0241\x03\x02\x02\x02\u0243\u0244\x03\x02\x02\x02" + + "\u0244\u0247\x03\x02\x02\x02\u0245\u0243\x03\x02\x02\x02\u0246\u023E\x03" + + "\x02\x02\x02\u0246\u0247\x03\x02\x02\x02\u0247\u0248\x03\x02\x02\x02\u0248" + + "\u024A\x07\xF9\x02\x02\u0249\u023D\x03\x02\x02\x02\u0249\u024A\x03\x02" + + "\x02\x02\u024A\u024B\x03\x02\x02\x02\u024B\u024C\x07\xA1\x02\x02\u024C" + + "\u024F\x05\u0148\xA5\x02\u024D\u024E\x07h\x02\x02\u024E\u0250\x05\u0148" + + "\xA5\x02\u024F\u024D\x03\x02\x02\x02\u024F\u0250\x03\x02\x02\x02\u0250" + + "\u0251\x03\x02\x02\x02\u0251\u0252\x07\x1A\x02\x02\u0252\u0256\x07\u0101" + + "\x02\x02\u0253\u0254\x07j\x02\x02\u0254\u0255\x07\xE8\x02\x02\u0255\u0257" + + "\x07\u0101\x02\x02\u0256\u0253\x03\x02\x02\x02\u0256\u0257\x03\x02\x02" + + "\x02\u0257\u0258\x03\x02\x02\x02\u0258\u0259\x07\xD0\x02\x02\u0259\u025A" + + "\x07\xE8\x02\x02\u025A\u025B\x07\u0101\x02\x02\u025B\u025C\x07\x7F\x02" + + "\x02\u025C\u025D\x07\xE8\x02\x02\u025D\u0261\x07\u0101\x02\x02\u025E\u025F" + + "\x07\x14\x02\x02\u025F\u0260\x07\xE8\x02\x02\u0260\u0262\x07\u0101\x02" + + "\x02\u0261\u025E\x03\x02\x02\x02\u0261\u0262\x03\x02\x02\x02\u0262\u0266" + + "\x03\x02\x02\x02\u0263\u0264\x07\x16\x02\x02\u0264\u0265\x07\xE8\x02\x02" + + "\u0265\u0267\x07\u0101\x02\x02\u0266\u0263\x03\x02\x02\x02\u0266\u0267" + + "\x03\x02\x02\x02\u0267\u026B\x03\x02\x02\x02\u0268\u0269\x07\xBD\x02\x02" + + "\u0269\u026A\x07\xE8\x02\x02\u026A\u026C\x07\u0101\x02\x02\u026B\u0268" + + "\x03\x02\x02\x02\u026B\u026C\x03\x02\x02\x02\u026C\u0270\x03\x02\x02\x02" + + "\u026D\u026E\x07N\x02\x02\u026E\u026F\x07\xE8\x02\x02\u026F\u0271\x07" + + "\u0101\x02\x02\u0270\u026D\x03\x02\x02\x02\u0270\u0271\x03\x02\x02\x02" + + "\u0271\x17\x03\x02\x02\x02\u0272\u0273\x07\'\x02\x02\u0273\u0275\x07V" + + "\x02\x02\u0274\u0276\x05\xACW\x02\u0275\u0274\x03\x02\x02\x02\u0275\u0276" + + "\x03\x02\x02\x02\u0276\u0277\x03\x02\x02\x02\u0277\u0284\x05\xB4[\x02" + + "\u0278\u0281\x07\xF8\x02\x02\u0279\u027E\x05\u0148\xA5\x02\u027A\u027B" + + "\x07\xF6\x02\x02\u027B\u027D\x05\u0148\xA5\x02\u027C\u027A\x03\x02\x02" + + "\x02\u027D\u0280\x03\x02\x02\x02\u027E\u027C\x03\x02\x02\x02\u027E\u027F" + + "\x03\x02\x02\x02\u027F\u0282\x03\x02\x02\x02\u0280\u027E\x03\x02\x02\x02" + + "\u0281\u0279\x03\x02\x02\x02\u0281\u0282\x03\x02\x02\x02\u0282\u0283\x03" + + "\x02\x02\x02\u0283\u0285\x07\xF9\x02\x02\u0284\u0278\x03\x02\x02\x02\u0284" + + "\u0285\x03\x02\x02\x02\u0285\u0288\x03\x02\x02\x02\u0286\u0287\x07\xA1" + + "\x02\x02\u0287\u0289\x05\u0148\xA5\x02\u0288\u0286\x03\x02\x02\x02\u0288" + + "\u0289\x03\x02\x02\x02\u0289\u028A\x03\x02\x02\x02\u028A\u028B\x07\x1A" + + "\x02\x02\u028B\u028C\x07\u0101\x02\x02\u028C\u028D\x07\xBC\x02\x02\u028D" + + "\u028E\x07\xE8\x02\x02\u028E\u028F\x05\u013A\x9E\x02\u028F\x19\x03\x02" + + "\x02\x02\u0290\u02A3\x05\x1C\x0F\x02\u0291\u02A3\x05> \x02\u0292\u02A3" + + "\x05<\x1F\x02\u0293\u02A3\x05:\x1E\x02\u0294\u02A3\x056\x1C\x02\u0295" + + "\u02A3\x058\x1D\x02\u0296\u02A3\x054\x1B\x02\u0297\u02A3\x050\x19\x02" + + "\u0298\u02A3\x052\x1A\x02\u0299\u02A3\x05.\x18\x02\u029A\u02A3\x05,\x17" + + "\x02\u029B\u02A3\x05*\x16\x02\u029C\u02A3\x05(\x15\x02\u029D\u02A3\x05" + + "\"\x12\x02\u029E\u02A3\x05\x1E\x10\x02\u029F\u02A3\x05 \x11\x02\u02A0" + + "\u02A3\x05$\x13\x02\u02A1\u02A3\x05&\x14\x02\u02A2\u0290\x03\x02"; + private static readonly _serializedATNSegment2: string = + "\x02\x02\u02A2\u0291\x03\x02\x02\x02\u02A2\u0292\x03\x02\x02\x02\u02A2" + + "\u0293\x03\x02\x02\x02\u02A2\u0294\x03\x02\x02\x02\u02A2\u0295\x03\x02" + + "\x02\x02\u02A2\u0296\x03\x02\x02\x02\u02A2\u0297\x03\x02\x02\x02\u02A2" + + "\u0298\x03\x02\x02\x02\u02A2\u0299\x03\x02\x02\x02\u02A2\u029A\x03\x02" + + "\x02\x02\u02A2\u029B\x03\x02\x02\x02\u02A2\u029C\x03\x02\x02\x02\u02A2" + + "\u029D\x03\x02\x02\x02\u02A2\u029E\x03\x02\x02\x02\u02A2\u029F\x03\x02" + + "\x02\x02\u02A2\u02A0\x03\x02\x02\x02\u02A2\u02A1\x03\x02\x02\x02\u02A3" + + "\x1B\x03\x02\x02\x02\u02A4\u02A5\x07\x06\x02\x02\u02A5\u02A6\x070\x02" + + "\x02\u02A6\u02A7\x05\xB8]\x02\u02A7\u02A8\x07\xB1\x02\x02\u02A8\u02A9" + + "\x07\x8F\x02\x02\u02A9\u02AA\t\x03\x02\x02\u02AA\u02AB\x05\u0164\xB3\x02" + + "\u02AB\x1D\x03\x02\x02\x02\u02AC\u02AD\x07\x06\x02\x02\u02AD\u02AE\x07" + + "\xBE\x02\x02\u02AE\u02AF\x05\xBA^\x02\u02AF\u02B0\x07\xB1\x02\x02\u02B0" + + "\u02B1\x07\"\x02\x02\u02B1\u02B2\x07\xB7\x02\x02\u02B2\u02B3\x05\xC0a" + + "\x02\u02B3\u02B4\x07\xF8\x02\x02\u02B4\u02B5\x05\xE2r\x02\u02B5\u02B6" + + "\x07\xE8\x02\x02\u02B6\u02BC\x05\u013A\x9E\x02\u02B7\u02B8\x07\xF6\x02" + + "\x02\u02B8\u02B9\x05\xE2r\x02\u02B9\u02BA\x07\xE8\x02\x02\u02BA\u02BB" + + "\x05\u013A\x9E\x02\u02BB\u02BD\x03\x02\x02\x02\u02BC\u02B7\x03\x02\x02" + + "\x02\u02BC\u02BD\x03\x02\x02\x02\u02BD\u02BE\x03\x02\x02\x02\u02BE\u02BF" + + "\x07\xF9\x02\x02\u02BF\x1F\x03\x02\x02\x02\u02C0\u02C1\x07\x06\x02\x02" + + "\u02C1\u02C2\x07\xBE\x02\x02\u02C2\u02C5\x05\xBA^\x02\u02C3\u02C4\x07" + + "\x92\x02\x02\u02C4\u02C6\x05\u0130\x99\x02\u02C5\u02C3\x03\x02\x02\x02" + + "\u02C5\u02C6\x03\x02\x02\x02\u02C6\u02C7\x03\x02\x02\x02\u02C7\u02D2\x07" + + "\xB1\x02\x02\u02C8\u02C9\x07 \x02\x02\u02C9\u02CA\x07`\x02\x02\u02CA\u02CF" + + "\x05\u013A\x9E\x02\u02CB\u02CC\x07\xD9\x02\x02\u02CC\u02CD\x07\x98\x02" + + "\x02\u02CD\u02CE\x07\xE8\x02\x02\u02CE\u02D0\x05\u0166\xB4\x02\u02CF\u02CB" + + "\x03\x02\x02\x02\u02CF\u02D0\x03\x02\x02\x02\u02D0\u02D3\x03\x02\x02\x02" + + "\u02D1\u02D3\x07\xC7\x02\x02\u02D2\u02C8\x03\x02\x02\x02\u02D2\u02D1\x03" + + "\x02\x02\x02\u02D3!\x03\x02\x02\x02\u02D4\u02D5\x07\x06\x02\x02\u02D5" + + "\u02D6\x07\xBE\x02\x02\u02D6\u02D7\x05\xBA^\x02\u02D7\u02D8\x07!\x02\x02" + + "\u02D8\u02D9\x07\"\x02\x02\u02D9\u02DA\x05\xDAn\x02\u02DA#\x03\x02\x02" + + "\x02\u02DB\u02DC\x07\x06\x02\x02\u02DC\u02DD\x07\xBE\x02\x02\u02DD\u02DE" + + "\x05\xBA^\x02\u02DE\u02E0\x07<\x02\x02\u02DF\u02E1\x07\"\x02\x02\u02E0" + + "\u02DF\x03\x02\x02\x02\u02E0\u02E1\x03\x02\x02\x02\u02E1\u02E2\x03\x02" + + "\x02\x02\u02E2\u02E3\x05\xC0a\x02\u02E3%\x03\x02\x02\x02\u02E4\u02E5\x07" + + "\x06\x02\x02\u02E5\u02E6\x07\xBE\x02\x02\u02E6\u02E7\x05\xBA^\x02\u02E7" + + "\u02E8\x07\xB1\x02\x02\u02E8\u02E9\x07\x8F\x02\x02\u02E9\u02EA\t\x03\x02" + + "\x02\u02EA\u02EB\x05\u0164\xB3\x02\u02EB\'\x03\x02\x02\x02\u02EC\u02ED" + + "\x07\x06\x02\x02\u02ED\u02EE\x07\xBE\x02\x02\u02EE\u02F4\x05\xBA^\x02" + + "\u02EF\u02F5\x07\x9F\x02\x02\u02F0\u02F2\x07\x03\x02\x02\u02F1\u02F3\x05" + + "\xACW\x02\u02F2\u02F1\x03\x02\x02\x02\u02F2\u02F3\x03\x02\x02\x02\u02F3" + + "\u02F5\x03\x02\x02\x02\u02F4\u02EF\x03\x02\x02\x02\u02F4\u02F0\x03\x02" + + "\x02\x02\u02F5\u02F6\x03\x02\x02\x02\u02F6\u02F7\x07#\x02\x02\u02F7\u02F8" + + "\x07\xF8\x02\x02\u02F8\u02FD\x05\xDAn\x02\u02F9\u02FA\x07\xF6\x02\x02" + + "\u02FA\u02FC\x05\xDAn\x02\u02FB\u02F9\x03\x02\x02\x02\u02FC\u02FF\x03" + + "\x02\x02\x02\u02FD\u02FE\x03\x02\x02\x02\u02FD\u02FB\x03\x02\x02\x02\u02FE" + + "\u0300\x03\x02\x02\x02\u02FF\u02FD\x03\x02\x02\x02\u0300\u0301\x07\xF9" + + "\x02\x02\u0301)\x03\x02\x02\x02\u0302\u0303\x07\x06\x02\x02\u0303\u0304" + + "\x07\xBE\x02\x02\u0304\u0305\x05\xBA^\x02\u0305\u0306\x07\x03\x02\x02" + + "\u0306\u0308\x07\"\x02\x02\u0307\u0309\x05\xACW\x02\u0308\u0307\x03\x02" + + "\x02\x02\u0308\u0309\x03\x02\x02\x02\u0309\u030A\x03\x02\x02\x02\u030A" + + "\u030B\x05\xDCo\x02\u030B+\x03\x02\x02\x02\u030C\u030D\x07\x06\x02\x02" + + "\u030D\u030E\x07\xBE\x02\x02\u030E\u030F\x05\xBA^\x02\u030F\u0311\x07" + + "\x06\x02\x02\u0310\u0312\x07\"\x02\x02\u0311\u0310\x03\x02\x02\x02\u0311" + + "\u0312\x03\x02\x02\x02\u0312\u0313\x03\x02\x02\x02\u0313\u031C\x05\xC0" + + "a\x02\u0314\u0318\x07\xB1\x02\x02\u0315\u0319\x05\xE0q\x02\u0316\u0317" + + "\x07$\x02\x02\u0317\u0319\x05\u013A\x9E\x02\u0318\u0315\x03\x02\x02\x02" + + "\u0318\u0316\x03\x02\x02\x02\u0319\u031D\x03\x02\x02\x02\u031A\u031B\x07" + + "<\x02\x02\u031B\u031D\x075\x02\x02\u031C\u0314\x03\x02\x02\x02\u031C\u031A" + + "\x03\x02\x02\x02\u031D-\x03\x02\x02\x02\u031E\u031F\x07\x06\x02\x02\u031F" + + "\u0320\x07\xBE\x02\x02\u0320\u0321\x05\xBA^\x02\u0321\u0323\x07\x03\x02" + + "\x02\u0322\u0324\x05\xACW\x02\u0323\u0322\x03\x02\x02\x02\u0323\u0324" + + "\x03\x02\x02\x02\u0324\u0331\x03\x02\x02\x02\u0325\u0326\x07\x92\x02\x02" + + "\u0326\u0329\x05\u0130\x99\x02\u0327\u0328\x07\x1A\x02\x02\u0328\u032A" + + "\x05\u013A\x9E\x02\u0329\u0327\x03\x02\x02\x02\u0329\u032A\x03\x02\x02" + + "\x02\u032A\u032C\x03\x02\x02\x02\u032B\u032D\x05\xEEx\x02\u032C\u032B" + + "\x03\x02\x02\x02\u032C\u032D\x03\x02\x02\x02\u032D\u0332\x03\x02\x02\x02" + + "\u032E\u032F\x07\x9B\x02\x02\u032F\u0330\x07\x92\x02\x02\u0330\u0332\x05" + + "\xECw\x02\u0331\u0325\x03\x02\x02\x02\u0331\u032E\x03\x02\x02\x02\u0332" + + "/\x03\x02\x02\x02\u0333\u0334\x07\x06\x02\x02\u0334\u0335\x07\xBE\x02" + + "\x02\u0335\u0338\x05\xBA^\x02\u0336\u0337\x07\x92\x02\x02\u0337\u0339" + + "\x05\u0130\x99\x02\u0338\u0336\x03\x02\x02\x02\u0338\u0339\x03\x02\x02" + + "\x02\u0339\u033A\x03\x02\x02\x02\u033A\u0346\x07\xB1\x02\x02\u033B\u033C" + + "\x07J\x02\x02\u033C\u0347\x05\xE4s\x02\u033D\u033E\x07\xA9\x02\x02\u033E" + + "\u033F\x07Q\x02\x02\u033F\u0347\x05\xFC\x7F\x02\u0340\u0341\x07\x1A\x02" + + "\x02\u0341\u0347\x05\u013A\x9E\x02\u0342\u0343\x07\x1B\x02\x02\u0343\u0347" + + "\x05\xF6|\x02\u0344\u0345\x07\xB0\x02\x02\u0345\u0347\x05\xF6|\x02\u0346" + + "\u033B\x03\x02\x02\x02\u0346\u033D\x03\x02\x02\x02\u0346\u0340\x03\x02" + + "\x02\x02\u0346\u0342\x03\x02\x02\x02\u0346\u0344\x03\x02\x02\x02\u0347" + + "1\x03\x02\x02\x02\u0348\u0349\x07\x06\x02\x02\u0349\u034A\x07\xBE\x02" + + "\x02\u034A\u034B\x05\xBA^\x02\u034B\u034C\x07\x9C\x02\x02\u034C\u034D" + + "\x07\x93\x02\x02\u034D3\x03\x02\x02\x02\u034E\u034F\x07\x06\x02\x02\u034F" + + "\u0350\x07\xBE\x02\x02\u0350\u0351\x05\xBA^\x02\u0351\u0353\x07<\x02\x02" + + "\u0352\u0354\x05\xAAV\x02\u0353\u0352\x03\x02\x02\x02\u0353\u0354\x03" + + "\x02\x02\x02\u0354\u035D\x03\x02\x02\x02\u0355\u0356\x07\x92\x02\x02\u0356" + + "\u0358\x05\u0130\x99\x02\u0357\u0359\x07\x18\x02\x02\u0358\u0357\x03\x02" + + "\x02\x02\u0358\u0359\x03\x02\x02\x02\u0359\u035E\x03\x02\x02\x02\u035A" + + "\u035B\x07\x9B\x02\x02\u035B\u035C\x07\x92\x02\x02\u035C\u035E\x05\xEC" + + "w\x02\u035D\u0355\x03\x02\x02\x02\u035D\u035A\x03\x02\x02\x02\u035E5\x03" + + "\x02\x02\x02\u035F\u0360\x07\x06\x02\x02\u0360\u0361\x07\xD5\x02\x02\u0361" + + "\u0363\x05\xBC_\x02\u0362\u0364\x05\xCAf\x02\u0363\u0362\x03\x02\x02\x02" + + "\u0363\u0364\x03\x02\x02\x02\u0364\u0365\x03\x02\x02\x02\u0365\u0366\x07" + + "\v\x02\x02\u0366\u0367\x05\xCCg\x02\u03677\x03\x02\x02\x02\u0368\u0369" + + "\x07\x06\x02\x02\u0369\u036A\x07\xD5\x02\x02\u036A\u036B\x05\xBC_\x02" + + "\u036B\u036C\x07\x9D\x02\x02\u036C\u036D\x07\xC3\x02\x02\u036D\u036E\x05" + + "\xBC_\x02\u036E9\x03\x02\x02\x02\u036F\u0370\x07\x06\x02\x02\u0370\u0371" + + "\x07\xD5\x02\x02\u0371\u0372\x05\xBC_\x02\u0372\u0373\x07\xB1\x02\x02" + + "\u0373\u0374\x07\x8F\x02\x02\u0374\u0375\t\x03\x02\x02\u0375\u0376\x05" + + "\u0160\xB1\x02\u0376;\x03\x02\x02\x02\u0377\u0378\x07\x06\x02\x02\u0378" + + "\u0379\x07\xBE\x02\x02\u0379\u037A\x05\xBA^\x02\u037A\u037B\x07\x9D\x02" + + "\x02\u037B\u037C\x07\xC3\x02\x02\u037C\u037D\x05\xBA^\x02\u037D=\x03\x02" + + "\x02\x02\u037E\u037F\x07\x06\x02\x02\u037F\u0380\x07\xD5\x02\x02\u0380" + + "\u0381\x05\xBC_\x02\u0381\u0382\t\x04\x02\x02\u0382\u0383\x07\x1B\x02" + + "\x02\u0383\u0384\x05\xF6|\x02\u0384?\x03\x02\x02\x02\u0385\u0387\x07\xC6" + + "\x02\x02\u0386\u0388\x07\xBE\x02\x02\u0387\u0386\x03\x02\x02\x02\u0387" + + "\u0388\x03\x02\x02\x02\u0388\u038A\x03\x02\x02\x02\u0389\u038B\x05\xAA" + + "V\x02\u038A\u0389\x03\x02\x02\x02\u038A\u038B\x03\x02\x02\x02\u038B\u038C" + + "\x03\x02\x02\x02\u038C\u038D\x05\xBA^\x02\u038DA\x03\x02\x02\x02\u038E" + + "\u0390\x07:\x02\x02\u038F\u0391\x070\x02\x02\u0390\u038F\x03\x02\x02\x02" + + "\u0390\u0391\x03\x02\x02\x02\u0391\u0393\x03\x02\x02\x02\u0392\u0394\t" + + "\x05\x02\x02\u0393\u0392\x03\x02\x02\x02\u0393\u0394\x03\x02\x02\x02\u0394" + + "\u0395\x03\x02\x02\x02\u0395\u0396\x05\u0160\xB1\x02\u0396C\x03\x02\x02" + + "\x02\u0397\u039A\x05F$\x02\u0398\u039A\x05H%\x02\u0399\u0397\x03\x02\x02" + + "\x02\u0399\u0398\x03\x02\x02\x02\u039AE\x03\x02\x02\x02\u039B\u039C\x07" + + "&\x02\x02\u039C\u039D\x07\xB7\x02\x02\u039D\u039F\x05\xBA^\x02\u039E\u03A0" + + "\x05\u0122\x92\x02\u039F\u039E\x03\x02\x02\x02\u039F\u03A0\x03\x02\x02" + + "\x02\u03A0\u03AD\x03\x02\x02\x02\u03A1\u03A2\x07\xC0\x02\x02\u03A2\u03A3" + + "\x07\xBB\x02\x02\u03A3\u03A4\x07\xF8\x02\x02\u03A4\u03A5\x05\u0166\xB4" + + "\x02\u03A5\u03AB\x07\xF9\x02\x02\u03A6\u03A7\x07\x9E\x02\x02\u03A7\u03A8" + + "\x07\xF8\x02\x02\u03A8\u03A9\x05\u0166\xB4\x02\u03A9\u03AA\x07\xF9\x02" + + "\x02\u03AA\u03AC\x03\x02\x02\x02\u03AB\u03A6\x03\x02\x02\x02\u03AB\u03AC" + + "\x03\x02\x02\x02\u03AC\u03AE\x03\x02\x02\x02\u03AD\u03A1\x03\x02\x02\x02" + + "\u03AD\u03AE\x03\x02\x02\x02\u03AEG\x03\x02\x02\x02\u03AF\u03B0\x07&\x02" + + "\x02\u03B0\u03B1\x07b\x02\x02\u03B1\u03B2\x07\xB7\x02\x02\u03B2\u03B5" + + "\x05\xBA^\x02\u03B3\u03B4\x07\x92\x02\x02\u03B4\u03B6\x05\u0130\x99\x02" + + "\u03B5\u03B3\x03\x02\x02\x02\u03B5\u03B6\x03\x02\x02\x02\u03B6I\x03\x02" + + "\x02\x02\u03B7\u03BE\x05V,\x02\u03B8\u03BE\x05T+\x02\u03B9\u03BE\x05R" + + "*\x02\u03BA\u03BE\x05N(\x02\u03BB\u03BE\x05P)\x02\u03BC\u03BE\x05L\'\x02" + + "\u03BD\u03B7\x03\x02\x02\x02\u03BD\u03B8\x03\x02\x02\x02\u03BD\u03B9\x03" + + "\x02\x02\x02\u03BD\u03BA\x03\x02\x02\x02\u03BD\u03BB\x03\x02\x02\x02\u03BD" + + "\u03BC\x03\x02\x02\x02\u03BEK\x03\x02\x02\x02\u03BF\u03C0\x07<\x02\x02" + + "\u03C0\u03C2\t\x02\x02\x02\u03C1\u03C3\x05\xAAV\x02\u03C2\u03C1\x03\x02" + + "\x02\x02\u03C2\u03C3\x03\x02\x02\x02\u03C3\u03C4\x03\x02\x02\x02\u03C4" + + "\u03C6\x05\xB8]\x02\u03C5\u03C7\t\x06\x02\x02\u03C6\u03C5\x03\x02\x02" + + "\x02\u03C6\u03C7\x03\x02\x02\x02\u03C7M\x03\x02\x02\x02\u03C8\u03C9\x07" + + "<\x02\x02\u03C9\u03CB\x07\xD5\x02\x02\u03CA\u03CC\x05\xAAV\x02\u03CB\u03CA" + + "\x03\x02\x02\x02\u03CB\u03CC\x03\x02\x02\x02\u03CC\u03CD\x03\x02\x02\x02" + + "\u03CD\u03CE\x05\xBC_\x02\u03CEO\x03\x02\x02\x02\u03CF\u03D0\x07<\x02" + + "\x02\u03D0\u03D2\x07\xBE\x02\x02\u03D1\u03D3\x05\xAAV\x02\u03D2\u03D1" + + "\x03\x02\x02\x02\u03D2\u03D3\x03\x02\x02\x02\u03D3\u03D4\x03\x02\x02\x02" + + "\u03D4\u03D6\x05\xBA^\x02\u03D5\u03D7\x07\x18\x02\x02\u03D6\u03D5\x03" + + "\x02\x02\x02\u03D6\u03D7\x03\x02\x02\x02\u03D7Q\x03\x02\x02\x02\u03D8" + + "\u03DA\x07<\x02\x02\u03D9\u03DB\x07b\x02\x02\u03DA\u03D9\x03\x02\x02\x02" + + "\u03DA\u03DB\x03\x02\x02\x02\u03DB\u03DC\x03\x02\x02\x02\u03DC\u03DD\x07" + + "\xB7\x02\x02\u03DD\u03E0\x05\xBA^\x02\u03DE\u03DF\x07\x92\x02\x02\u03DF" + + "\u03E1\x05\u0130\x99\x02\u03E0\u03DE\x03\x02\x02\x02\u03E0\u03E1\x03\x02" + + "\x02\x02\u03E1S\x03\x02\x02\x02\u03E2\u03E4\x07<\x02\x02\u03E3\u03E5\x07" + + "\x0E\x02\x02\u03E4\u03E3\x03\x02\x02\x02\u03E4\u03E5\x03\x02\x02\x02\u03E5" + + "\u03E6\x03\x02\x02\x02\u03E6\u03E8\x07V\x02\x02\u03E7\u03E9\x05\xAAV\x02" + + "\u03E8\u03E7\x03\x02\x02\x02\u03E8\u03E9\x03\x02\x02\x02\u03E9\u03EA\x03" + + "\x02\x02\x02\u03EA\u03F7\x05\xBE`\x02\u03EB\u03F4\x07\xF8\x02\x02\u03EC" + + "\u03F1\x05\u0148\xA5\x02\u03ED\u03EE\x07\xF6\x02\x02\u03EE\u03F0\x05\u0148" + + "\xA5\x02\u03EF\u03ED\x03\x02\x02\x02\u03F0\u03F3\x03\x02\x02\x02\u03F1" + + "\u03EF\x03\x02\x02\x02\u03F1\u03F2\x03\x02\x02\x02\u03F2\u03F5\x03\x02" + + "\x02\x02\u03F3\u03F1\x03\x02\x02\x02\u03F4\u03EC\x03\x02\x02\x02\u03F4" + + "\u03F5\x03\x02\x02\x02\u03F5\u03F6\x03\x02\x02\x02\u03F6\u03F8\x07\xF9" + + "\x02\x02\u03F7\u03EB\x03\x02\x02\x02\u03F7\u03F8\x03\x02\x02\x02\u03F8" + + "U\x03\x02\x02\x02\u03F9\u03FA\x07<\x02\x02\u03FA\u03FB\x07\xA7\x02\x02" + + "\u03FB\u03FC\x05\u0164\xB3\x02\u03FCW\x03\x02\x02\x02\u03FD\u0400\x05" + + "Z.\x02\u03FE\u0400\x05\\/\x02\u03FF\u03FD\x03\x02\x02\x02\u03FF\u03FE" + + "\x03\x02\x02\x02\u0400Y\x03\x02\x02\x02\u0401\u0402\x07X\x02\x02\u0402" + + "\u0403\x07\xA7\x02\x02\u0403\u0404\x05\u0164\xB3\x02\u0404\u0405\x07\xC3" + + "\x02\x02\u0405\u0406\x07Y\x02\x02\u0406\u0407\x05\u0164\xB3\x02\u0407" + + "[\x03\x02\x02\x02\u0408\u0409\x07X\x02\x02\u0409\u040A\x05\u015C\xAF\x02" + + "\u040A\u040B\x07\x89\x02\x02\u040B\u040D\x05\u015E\xB0\x02\u040C\u040E" + + "\x05\u0160\xB1\x02\u040D\u040C\x03\x02\x02\x02\u040D\u040E\x03\x02\x02" + + "\x02\u040E\u040F\x03\x02\x02\x02\u040F\u0410\x07\xC3\x02\x02\u0410\u0411" + + "\x05\u0162\xB2\x02\u0411]\x03\x02\x02\x02\u0412\u0415\x05`1\x02\u0413" + + "\u0415\x05b2\x02\u0414\u0412\x03\x02\x02\x02\u0414\u0413\x03\x02\x02\x02" + + "\u0415_\x03\x02\x02\x02\u0416\u0417\x07\xA2\x02\x02\u0417\u0418\x07\xA7" + + "\x02\x02\u0418\u0419\x05\u0164\xB3\x02\u0419\u041A\x07T\x02\x02\u041A" + + "\u041B\x07Y\x02\x02\u041B\u041C\x05\u0164\xB3\x02\u041Ca\x03\x02\x02\x02" + + "\u041D\u0421\x07\xA2\x02\x02\u041E\u041F\x07X\x02\x02\u041F\u0420\x07" + + "\x8A\x02\x02\u0420\u0422\x07P\x02\x02\u0421\u041E\x03\x02\x02\x02\u0421" + + "\u0422\x03\x02\x02\x02\u0422\u0423\x03\x02\x02\x02\u0423\u0424\x05\u015C" + + "\xAF\x02\u0424\u0425\x07\x89\x02\x02\u0425\u0427\x05\u015E\xB0\x02\u0426" + + "\u0428\x05\u0160\xB1\x02\u0427\u0426\x03\x02\x02\x02\u0427\u0428\x03\x02" + + "\x02\x02\u0428\u0429\x03\x02\x02\x02\u0429\u042F\x07T\x02\x02\u042A\u0430" + + "\x05\u0162\xB2\x02\u042B\u042D\x07\xA7\x02\x02\u042C\u042B\x03\x02\x02" + + "\x02\u042C\u042D\x03\x02\x02\x02\u042D\u042E\x03\x02\x02\x02\u042E\u0430" + + "\x05\u0164\xB3\x02\u042F\u042A\x03\x02\x02\x02\u042F\u042C\x03\x02\x02" + + "\x02\u0430c\x03\x02\x02\x02\u0431\u0433\x05\xCEh\x02\u0432\u0431\x03\x02" + + "\x02\x02\u0432\u0433\x03\x02\x02\x02\u0433\u0434\x03\x02\x02\x02\u0434" + + "\u0435\x07e\x02\x02\u0435\u0437\t\x07\x02\x02\u0436\u0438\x07\xBE\x02" + + "\x02\u0437\u0436\x03\x02\x02\x02\u0437\u0438\x03\x02\x02\x02\u0438\u0439" + + "\x03\x02\x02\x02\u0439\u043B\x05\xBA^\x02\u043A\u043C\x05\u0122\x92\x02" + + "\u043B\u043A\x03\x02\x02\x02\u043B\u043C\x03\x02\x02\x02\u043C\u0449\x03" + + "\x02\x02\x02\u043D\u043E\x07\x92\x02\x02\u043E\u043F\x07\xF8\x02\x02\u043F" + + "\u0444\x05\u0130\x99\x02\u0440\u0441\x07\xF6\x02\x02\u0441\u0443\x05\u0130" + + "\x99\x02\u0442\u0440\x03\x02\x02\x02\u0443\u0446\x03\x02\x02\x02\u0444" + + "\u0442\x03\x02\x02\x02\u0444\u0445\x03\x02\x02\x02\u0445\u0447\x03\x02" + + "\x02\x02\u0446\u0444\x03\x02\x02\x02\u0447\u0448\x07\xF9\x02\x02\u0448" + + "\u044A\x03\x02\x02\x02\u0449\u043D\x03\x02\x02\x02\u0449\u044A\x03\x02" + + "\x02\x02\u044A\u044B\x03\x02\x02\x02\u044B\u044C\x05\xCCg\x02\u044Ce\x03" + + "\x02\x02\x02\u044D\u0450\x05h5\x02\u044E\u0450\x05j6\x02\u044F\u044D\x03" + + "\x02\x02\x02\u044F\u044E\x03\x02\x02\x02\u0450g\x03\x02\x02\x02\u0451" + + "\u0453\x074\x02\x02\u0452\u0454\x07T\x02\x02\u0453\u0452\x03\x02\x02\x02" + + "\u0453\u0454\x03\x02\x02\x02\u0454\u0455\x03\x02\x02\x02\u0455\u0458\x05" + + "\xBA^\x02\u0456\u0457\x07\xD8\x02\x02\u0457\u0459\x05\u0132\x9A\x02\u0458" + + "\u0456\x03\x02\x02\x02\u0458\u0459\x03\x02\x02\x02\u0459i\x03\x02\x02" + + "\x02\u045A\u045B\x074\x02\x02\u045B\u0460\x05\xBA^\x02\u045C\u045E\x07" + + "\v\x02\x02\u045D\u045C\x03\x02\x02\x02\u045D\u045E\x03\x02\x02\x02\u045E" + + "\u045F\x03\x02\x02\x02\u045F\u0461\x05\u0164\xB3\x02\u0460\u045D\x03\x02" + + "\x02\x02\u0460\u0461\x03\x02\x02\x02\u0461\u0462\x03\x02\x02\x02\u0462" + + "\u046B\x07T\x02\x02\u0463\u0468\x05\u0116\x8C\x02\u0464\u0465\x07\xF6" + + "\x02\x02\u0465\u0467\x05\u0116\x8C\x02\u0466\u0464\x03\x02\x02\x02\u0467" + + "\u046A\x03\x02\x02\x02\u0468\u0466\x03\x02\x02\x02\u0468\u0469\x03\x02" + + "\x02\x02\u0469\u046C\x03\x02\x02\x02\u046A\u0468\x03\x02\x02\x02\u046B" + + "\u0463\x03\x02\x02\x02\u046B\u046C\x03\x02\x02\x02\u046C\u046F\x03\x02" + + "\x02\x02\u046D\u046E\x07\xD8\x02\x02\u046E\u0470\x05\u0132\x9A\x02\u046F" + + "\u046D\x03\x02\x02\x02\u046F\u0470\x03\x02\x02\x02\u0470k\x03\x02\x02" + + "\x02\u0471\u0472\x078\x02\x02\u0472\u0473\x05\xBA^\x02\u0473\u0474\x07" + + "\xB1\x02\x02\u0474\u047E\x05\xC6d\x02\u0475\u0476\x07T\x02\x02\u0476\u047B" + + "\x05\u0116\x8C\x02\u0477\u0478\x07\xF6\x02\x02\u0478\u047A\x05\u0116\x8C" + + "\x02\u0479\u0477\x03\x02\x02\x02\u047A\u047D\x03\x02\x02\x02\u047B\u0479" + + "\x03\x02\x02\x02\u047B\u047C\x03\x02\x02\x02\u047C\u047F\x03\x02\x02\x02" + + "\u047D\u047B\x03\x02\x02\x02\u047E\u0475\x03\x02\x02\x02\u047E\u047F\x03" + + "\x02\x02\x02\u047F\u0482\x03\x02\x02\x02\u0480\u0481\x07\xD8\x02\x02\u0481" + + "\u0483\x05\u0132\x9A\x02\u0482\u0480\x03\x02\x02\x02\u0482\u0483\x03\x02" + + "\x02\x02\u0483m\x03\x02\x02\x02\u0484\u0485\x07\xD1\x02\x02\u0485\u0487" + + "\x07i\x02\x02\u0486\u0488\x07\xBE\x02\x02\u0487\u0486\x03\x02\x02\x02" + + "\u0487\u0488\x03\x02\x02\x02\u0488\u0489\x03\x02\x02\x02\u0489\u048B\x05" + + "\xBA^\x02\u048A\u048C\x05\u0122\x92\x02\u048B\u048A\x03\x02\x02\x02\u048B" + + "\u048C\x03\x02\x02\x02\u048C\u048D\x03\x02\x02\x02\u048D\u048E\x05\xCC" + + "g\x02\u048Eo\x03\x02\x02\x02\u048F\u049C\x05\x84C\x02\u0490\u049C\x05" + + "\x86D\x02\u0491\u049C\x05\x88E\x02\u0492\u049C\x05\x82B\x02\u0493\u049C" + + "\x05\x80A\x02\u0494\u049C\x05~@\x02\u0495\u049C\x05|?\x02\u0496\u049C" + + "\x05z>\x02\u0497\u049C\x05x=\x02\u0498\u049C\x05v<\x02\u0499\u049C\x05" + + "t;\x02\u049A\u049C\x05r:\x02\u049B\u048F\x03\x02\x02\x02\u049B\u0490\x03" + + "\x02\x02\x02\u049B\u0491\x03\x02\x02\x02\u049B\u0492\x03\x02\x02\x02\u049B" + + "\u0493\x03\x02\x02\x02\u049B\u0494\x03\x02\x02\x02\u049B\u0495\x03\x02" + + "\x02\x02\u049B\u0496\x03\x02\x02\x02\u049B\u0497\x03\x02\x02\x02\u049B" + + "\u0498\x03\x02\x02\x02\u049B\u0499\x03\x02\x02\x02\u049B\u049A\x03\x02" + + "\x02\x02\u049Cq\x03\x02\x02\x02\u049D\u049E\x07\xB4\x02\x02\u049E\u04AA" + + "\t\b\x02\x02\u049F\u04A1\x07s\x02\x02\u04A0\u049F\x03\x02\x02\x02\u04A0" + + "\u04A1\x03\x02\x02\x02\u04A1\u04A2\x03\x02\x02\x02\u04A2\u04A7\x05\u013A" + + "\x9E\x02\u04A3\u04A4\x07\xFE\x02\x02\u04A4\u04A6\x05\u013A\x9E\x02\u04A5" + + "\u04A3\x03\x02\x02\x02\u04A6\u04A9\x03\x02\x02\x02\u04A7\u04A5\x03\x02" + + "\x02\x02\u04A7\u04A8\x03\x02\x02\x02\u04A8\u04AB\x03\x02\x02\x02\u04A9" + + "\u04A7\x03\x02\x02\x02\u04AA\u04A0\x03\x02\x02\x02\u04AA\u04AB\x03\x02" + + "\x02\x02\u04ABs\x03\x02\x02\x02\u04AC\u04AD\x07\xB4\x02\x02\u04AD\u04B0" + + "\x07\xBF\x02\x02\u04AE\u04AF\x07`\x02\x02\u04AF\u04B1\x05\xBA^\x02\u04B0" + + "\u04AE\x03\x02\x02\x02\u04B0\u04B1\x03\x02\x02\x02\u04B1\u04BD\x03\x02" + + "\x02\x02\u04B2\u04B4\x07s\x02\x02\u04B3\u04B2\x03\x02\x02\x02\u04B3\u04B4" + + "\x03\x02\x02\x02\u04B4\u04B5\x03\x02\x02\x02\u04B5\u04BA\x05\u013A\x9E" + + "\x02\u04B6\u04B7\x07\xFE\x02\x02\u04B7\u04B9\x05\u013A\x9E\x02\u04B8\u04B6" + + "\x03\x02\x02\x02\u04B9\u04BC\x03\x02\x02\x02\u04BA\u04B8\x03\x02\x02\x02" + + "\u04BA\u04BB\x03\x02\x02\x02\u04BB\u04BE\x03\x02\x02\x02\u04BC\u04BA\x03" + + "\x02\x02\x02\u04BD\u04B3\x03\x02\x02\x02\u04BD\u04BE\x03\x02\x02\x02\u04BE" + + "u\x03\x02\x02\x02\u04BF\u04C1\x07\xB4\x02\x02\u04C0\u04C2\t\t\x02\x02" + + "\u04C1\u04C0\x03\x02\x02\x02\u04C1\u04C2\x03\x02\x02\x02\u04C2\u04C3\x03" + + "\x02\x02\x02\u04C3\u04C6\x07W\x02\x02\u04C4\u04C5\x07`\x02\x02\u04C5\u04C7" + + "\x05\xB8]\x02\u04C6\u04C4\x03\x02\x02\x02\u04C6\u04C7\x03\x02\x02\x02" + + "\u04C7\u04D3\x03\x02\x02\x02\u04C8\u04CA\x07s\x02\x02\u04C9\u04C8\x03" + + "\x02\x02\x02\u04C9\u04CA\x03\x02\x02\x02\u04CA\u04CB\x03\x02\x02\x02\u04CB" + + "\u04D0\x05\u013A\x9E\x02\u04CC\u04CD\x07\xFE\x02\x02\u04CD\u04CF\x05\u013A" + + "\x9E\x02\u04CE\u04CC\x03\x02\x02\x02\u04CF\u04D2\x03\x02\x02\x02\u04D0" + + "\u04CE\x03\x02\x02\x02\u04D0\u04D1\x03\x02\x02\x02\u04D1\u04D4\x03\x02" + + "\x02\x02\u04D2\u04D0\x03\x02\x02\x02\u04D3\u04C9\x03\x02\x02\x02\u04D3" + + "\u04D4\x03\x02\x02\x02\u04D4w\x03\x02\x02\x02\u04D5\u04D6\x07\xB4\x02" + + "\x02\u04D6\u04D7\x07\'\x02\x02\u04D7\u04D8\x07\xBE\x02\x02\u04D8\u04D9" + + "\x05\xBA^\x02\u04D9y\x03\x02\x02\x02\u04DA\u04DB\x07\xB4\x02\x02\u04DB" + + "\u04DC\x07\'\x02\x02\u04DC\u04DD\x07\xD5\x02\x02\u04DD\u04DE\x05\xBC_" + + "\x02\u04DE{\x03\x02\x02\x02\u04DF\u04E0\x07\xB4\x02\x02\u04E0\u04E1\x07" + + "\xBE\x02\x02\u04E1\u04E2\x07\xB7\x02\x02\u04E2\u04E3\x05\xBA^\x02\u04E3" + + "}\x03\x02\x02\x02\u04E4\u04E5\x07\xB4\x02\x02\u04E5\u04E6\x07\"\x02\x02" + + "\u04E6\u04E7\x07\xB7\x02\x02\u04E7\u04E8\x05\xBA^\x02\u04E8\x7F\x03\x02" + + "\x02\x02\u04E9\u04EB\x07\xB4\x02\x02\u04EA\u04EC\x07\x9B\x02\x02\u04EB" + + "\u04EA\x03\x02\x02\x02\u04EB\u04EC\x03\x02\x02\x02\u04EC\u04ED\x03\x02" + + "\x02\x02\u04ED\u04EE\x07\x93\x02\x02\u04EE\u04EF\x05\xBA^\x02\u04EF\x81" + + "\x03\x02\x02\x02\u04F0\u04F1\x07\xB4\x02\x02\u04F1\u04F2\x07K\x02\x02" + + "\u04F2\u04F3\x07`\x02\x02\u04F3\u04FD\x05\xBA^\x02\u04F4\u04F5\x07\x92" + + "\x02\x02\u04F5\u04F6\x07\xF8\x02\x02\u04F6\u04F9\x05\u0130\x99\x02\u04F7" + + "\u04F8\x07\xF6\x02\x02\u04F8\u04FA\x05\u0130\x99\x02\u04F9\u04F7\x03\x02" + + "\x02\x02\u04F9\u04FA\x03\x02\x02\x02\u04FA\u04FB\x03\x02\x02\x02\u04FB" + + "\u04FC\x07\xF9\x02\x02\u04FC\u04FE\x03\x02\x02\x02\u04FD\u04F4\x03\x02" + + "\x02\x02\u04FD\u04FE\x03\x02\x02\x02\u04FE\x83\x03\x02\x02\x02\u04FF\u0501" + + "\x07\xB4\x02\x02\u0500\u0502\x07)\x02\x02\u0501\u0500\x03\x02\x02\x02" + + "\u0501\u0502\x03\x02\x02\x02\u0502\u0503\x03\x02\x02\x02\u0503\u0504\x07" + + "\xA8\x02\x02\u0504\x85\x03\x02\x02\x02\u0505\u0506\x07\xB4\x02\x02\u0506" + + "\u0507\x07\xA7\x02\x02\u0507\u0508\x07X\x02\x02\u0508\u0509\x07Y\x02\x02" + + "\u0509\u050A\x05\u0164\xB3\x02\u050A\x87\x03\x02\x02\x02\u050B\u051A\x05" + + "\x8AF\x02\u050C\u051A\x05\x8CG\x02\u050D\u051A\x05\x8EH\x02\u050E\u050F" + + "\x07\xB4\x02\x02\u050F\u0510\x07X\x02\x02\u0510\u0511\t\n\x02\x02\u0511" + + "\u0517\x05\u0164\xB3\x02\u0512\u0513\x07\x89\x02\x02\u0513\u0515\t\v\x02" + + "\x02\u0514\u0516\x05\u0160\xB1\x02\u0515\u0514\x03\x02\x02\x02\u0515\u0516" + + "\x03\x02\x02\x02\u0516\u0518\x03\x02\x02\x02\u0517\u0512\x03\x02\x02\x02" + + "\u0517\u0518\x03\x02\x02\x02\u0518\u051A\x03\x02\x02\x02\u0519\u050B\x03" + + "\x02\x02\x02\u0519\u050C\x03\x02\x02\x02\u0519\u050D\x03\x02\x02\x02\u0519" + + "\u050E\x03\x02\x02\x02\u051A\x89\x03\x02\x02\x02\u051B\u051C\x07\xB4\x02" + + "\x02\u051C\u051D\x07X\x02\x02\u051D\u051E\t\n\x02\x02\u051E\u0524\x05" + + "\u0164\xB3\x02\u051F\u0520\x07\x89\x02\x02\u0520\u0522\x070\x02\x02\u0521" + + "\u0523\x05\xB8]\x02\u0522\u0521\x03\x02\x02\x02\u0522\u0523\x03\x02\x02" + + "\x02\u0523\u0525\x03\x02\x02\x02\u0524\u051F\x03\x02\x02\x02\u0524\u0525" + + "\x03\x02\x02\x02\u0525\x8B\x03\x02\x02\x02\u0526\u0527\x07\xB4\x02\x02" + + "\u0527\u0528\x07X\x02\x02\u0528\u0529\t\n\x02\x02\u0529\u052F\x05\u0164" + + "\xB3\x02\u052A\u052B\x07\x89\x02\x02\u052B\u052D\x07\xBE\x02\x02\u052C" + + "\u052E\x05\xBA^\x02\u052D\u052C\x03\x02\x02\x02\u052D\u052E\x03\x02\x02" + + "\x02\u052E\u0530\x03\x02\x02\x02\u052F\u052A\x03\x02\x02\x02\u052F\u0530" + + "\x03\x02\x02\x02\u0530\x8D\x03\x02\x02\x02\u0531\u0532\x07\xB4\x02\x02" + + "\u0532\u0533\x07X\x02\x02\u0533\u0534\t\n\x02\x02\u0534\u053A\x05\u0164" + + "\xB3\x02\u0535\u0536\x07\x89\x02\x02\u0536\u0538\x07\"\x02\x02\u0537\u0539" + + "\x05\xC0a\x02\u0538\u0537\x03\x02\x02\x02\u0538\u0539\x03\x02\x02\x02" + + "\u0539\u053B\x03\x02\x02\x02\u053A\u0535\x03\x02\x02\x02\u053A\u053B\x03" + + "\x02\x02\x02\u053B\x8F\x03\x02\x02\x02\u053C\u0540\x05\x92J\x02\u053D" + + "\u0540\x05\x94K\x02\u053E\u0540\x05\x96L\x02\u053F\u053C\x03\x02\x02\x02" + + "\u053F\u053D\x03\x02\x02\x02\u053F\u053E\x03\x02\x02\x02\u0540\x91\x03" + + "\x02\x02\x02\u0541\u0542\x07$\x02\x02\u0542\u0543\x07\x89\x02\x02\u0543" + + "\u0544\x070\x02\x02\u0544\u0545\x05\xB8]\x02\u0545\u0548\x07l\x02\x02" + + "\u0546\u0549\x05\u013A\x9E\x02\u0547\u0549\x07\x86\x02\x02\u0548\u0546" + + "\x03\x02\x02\x02\u0548\u0547\x03\x02\x02\x02\u0549\x93\x03\x02\x02\x02" + + "\u054A\u054B\x07$\x02\x02\u054B\u054C\x07\x89\x02\x02\u054C\u054D\x07" + + "\xBE\x02\x02\u054D\u054E\x05\xBA^\x02\u054E\u0551\x07l\x02\x02\u054F\u0552" + + "\x05\u013A\x9E\x02\u0550\u0552\x07\x86\x02\x02\u0551\u054F\x03\x02\x02" + + "\x02\u0551\u0550\x03\x02\x02\x02\u0552\x95\x03\x02\x02\x02\u0553\u0554" + + "\x07$\x02\x02\u0554\u0555\x07\x89\x02\x02\u0555\u0556\x07\"\x02\x02\u0556" + + "\u0557\x05\xC0a\x02\u0557\u055A\x07l\x02\x02\u0558\u055B\x05\u013A\x9E" + + "\x02\u0559\u055B\x07\x86\x02\x02\u055A\u0558\x03\x02\x02\x02\u055A\u0559" + + "\x03\x02\x02\x02\u055B\x97\x03\x02\x02\x02"; + private static readonly _serializedATNSegment3: string = + "\u055C\u055D\x07E\x02\x02\u055D\u055E\x05\x04\x03\x02\u055E\x99\x03\x02" + + "\x02\x02\u055F\u0565\x07\xB1\x02\x02\u0560\u0566\x07\x04\x02\x02\u0561" + + "\u0562\x05\u0164\xB3\x02\u0562\u0563\x07\xE8\x02\x02\u0563\u0564\x05\u0130" + + "\x99\x02\u0564\u0566\x03\x02\x02\x02\u0565\u0560\x03\x02\x02\x02\u0565" + + "\u0561\x03\x02\x02\x02\u0565\u0566\x03\x02\x02\x02\u0566\x9B\x03\x02\x02" + + "\x02\u0567\u0568\x07\xF7\x02\x02\u0568\u0569\x07\xB5\x02\x02\u0569\u0573" + + "\x07\xF8\x02\x02\u056A\u056C\x05\u013A\x9E\x02\u056B\u056A\x03\x02\x02" + + "\x02\u056B\u056C\x03\x02\x02\x02\u056C\u0574\x03\x02\x02\x02\u056D\u0570" + + "\x05\u013A\x9E\x02\u056E\u056F\x07\xF6\x02\x02\u056F\u0571\x05\u0130\x99" + + "\x02\u0570\u056E\x03\x02\x02\x02\u0570\u0571\x03\x02\x02\x02\u0571\u0574" + + "\x03\x02\x02\x02\u0572\u0574\x05\u0130\x99\x02\u0573\u056B\x03\x02\x02" + + "\x02\u0573\u056D\x03\x02\x02\x02\u0573\u0572\x03\x02\x02\x02\u0574\u0575" + + "\x03\x02\x02\x02\u0575\u0576\x07\xF9\x02\x02\u0576\x9D\x03\x02\x02\x02" + + "\u0577\u0578\x07k\x02\x02\u0578\u0579\x07y\x02\x02\u0579\u057A\x05\xBA" + + "^\x02\u057A\x9F\x03\x02\x02\x02\u057B\u057C\x07v\x02\x02\u057C\u057D\x07" + + "/\x02\x02\u057D\u057E\x07d\x02\x02\u057E\u0580\x07\u0101\x02\x02\u057F" + + "\u0581\x07\x91\x02\x02\u0580\u057F\x03\x02\x02\x02\u0580\u0581\x03\x02" + + "\x02\x02\u0581\u0582\x03\x02\x02\x02\u0582\u0583\x07i\x02\x02\u0583\u0584" + + "\x07\xBE\x02\x02\u0584\u058E\x05\xBA^\x02\u0585\u0586\x07\x92\x02\x02" + + "\u0586\u0587\x07\xF8\x02\x02\u0587\u058A\x05\u0130\x99\x02\u0588\u0589" + + "\x07\xF6\x02\x02\u0589\u058B\x05\u0130\x99\x02\u058A\u0588\x03\x02\x02" + + "\x02\u058A\u058B\x03\x02\x02\x02\u058B\u058C\x03\x02\x02\x02\u058C\u058D" + + "\x07\xF9\x02\x02\u058D\u058F\x03\x02\x02\x02\u058E\u0585\x03\x02\x02\x02" + + "\u058E\u058F\x03\x02\x02\x02\u058F\xA1\x03\x02\x02\x02\u0590\u0594\x05" + + "\xA4S\x02\u0591\u0594\x05\xA6T\x02\u0592\u0594\x05\xA8U\x02\u0593\u0590" + + "\x03\x02\x02\x02\u0593\u0591\x03\x02\x02\x02\u0593\u0592\x03\x02\x02\x02" + + "\u0594\xA3\x03\x02\x02\x02\u0595\u0596\x07\xA3\x02\x02\u0596\u05A3\x05" + + "\xBA^\x02\u0597\u0598\x07\x92\x02\x02\u0598\u0599\x07\xF8\x02\x02\u0599" + + "\u059E\x05\u0130\x99\x02\u059A\u059B\x07\xF6\x02\x02\u059B\u059D\x05\u0130" + + "\x99\x02\u059C\u059A\x03\x02\x02\x02\u059D\u05A0\x03\x02\x02\x02\u059E" + + "\u059F\x03\x02\x02\x02\u059E\u059C\x03\x02\x02\x02\u059F\u05A1\x03\x02" + + "\x02\x02\u05A0\u059E\x03\x02\x02\x02\u05A1\u05A2\x07\xF9\x02\x02\u05A2" + + "\u05A4\x03\x02\x02\x02\u05A3\u0597\x03\x02\x02\x02\u05A3\u05A4\x03\x02" + + "\x02\x02\u05A4\xA5\x03\x02\x02\x02\u05A5\u05A6\x07\xA3\x02\x02\u05A6\u05A7" + + "\x07\x0F\x02\x02\u05A7\xA7\x03\x02\x02\x02\u05A8\u05A9\x07\xA3\x02\x02" + + "\u05A9\u05AA\x07W\x02\x02\u05AA\u05AB\x05\xBE`\x02\u05AB\xA9\x03\x02\x02" + + "\x02\u05AC\u05AD\x07_\x02\x02\u05AD\u05AE\x07D\x02\x02\u05AE\xAB\x03\x02" + + "\x02\x02\u05AF\u05B0\x07_\x02\x02\u05B0\u05B1\x07\x85\x02\x02\u05B1\u05B2" + + "\x07D\x02\x02\u05B2\xAD\x03\x02\x02\x02\u05B3\u05B4\x05\u0160\xB1\x02" + + "\u05B4\xAF\x03\x02\x02\x02\u05B5\u05B6\x05\u0160\xB1\x02\u05B6\xB1\x03" + + "\x02\x02\x02\u05B7\u05B8\x05\u0160\xB1\x02\u05B8\xB3\x03\x02\x02\x02\u05B9" + + "\u05BA\x05\u0160\xB1\x02\u05BA\xB5\x03\x02\x02\x02\u05BB\u05BC\x05\u0160" + + "\xB1\x02\u05BC\xB7\x03\x02\x02\x02\u05BD\u05BE\x05\u0160\xB1\x02\u05BE" + + "\xB9\x03\x02\x02\x02\u05BF\u05C4\x05\u0164\xB3\x02\u05C0\u05C1\x07\xF4" + + "\x02\x02\u05C1\u05C3\x05\u0164\xB3\x02\u05C2\u05C0\x03\x02\x02\x02\u05C3" + + "\u05C6\x03\x02\x02\x02\u05C4\u05C2\x03\x02\x02\x02\u05C4\u05C5\x03\x02" + + "\x02\x02\u05C5\xBB\x03\x02\x02\x02\u05C6\u05C4\x03\x02\x02\x02\u05C7\u05CC" + + "\x05\u0164\xB3\x02\u05C8\u05C9\x07\xF4\x02\x02\u05C9\u05CB\x05\u0164\xB3" + + "\x02\u05CA\u05C8\x03\x02\x02\x02\u05CB\u05CE\x03\x02\x02\x02\u05CC\u05CA" + + "\x03\x02\x02\x02\u05CC\u05CD\x03\x02\x02\x02\u05CD\xBD\x03\x02\x02\x02" + + "\u05CE\u05CC\x03\x02\x02\x02\u05CF\u05D0\x05\u0160\xB1\x02\u05D0\xBF\x03" + + "\x02\x02\x02\u05D1\u05D2\x05\u0160\xB1\x02\u05D2\xC1\x03\x02\x02\x02\u05D3" + + "\u05D6\x05\xBA^\x02\u05D4\u05D6\x05\xBC_\x02\u05D5\u05D3\x03\x02\x02\x02" + + "\u05D5\u05D4\x03\x02\x02\x02\u05D6\xC3\x03\x02\x02\x02\u05D7\u05D8\x07" + + "\x17\x02\x02\u05D8\u05D9\x07\x1C\x02\x02\u05D9\u05DB\x05\u0122\x92\x02" + + "\u05DA\u05D7\x03\x02\x02\x02\u05DA\u05DB\x03\x02\x02\x02\u05DB\u05DE\x03" + + "\x02\x02\x02\u05DC\u05DD\x07$\x02\x02\u05DD\u05DF\x05\u013A\x9E\x02\u05DE" + + "\u05DC\x03\x02\x02\x02\u05DE\u05DF\x03\x02\x02\x02\u05DF\u05E3\x03\x02" + + "\x02\x02\u05E0\u05E1\x07\xA9\x02\x02\u05E1\u05E2\x07Q\x02\x02\u05E2\u05E4" + + "\x05\xFC\x7F\x02\u05E3\u05E0\x03\x02\x02\x02\u05E3\u05E4\x03\x02\x02\x02" + + "\u05E4\u05E8\x03\x02\x02\x02\u05E5\u05E6\x07\xD9\x02\x02\u05E6\u05E7\x07" + + "\xB0\x02\x02\u05E7\u05E9\x05\xF6|\x02\u05E8\u05E5\x03\x02\x02\x02\u05E8" + + "\u05E9\x03\x02\x02\x02\u05E9\u05ED\x03\x02\x02\x02\u05EA\u05EB\x07\x19" + + "\x02\x02\u05EB\u05EC\x07\v\x02\x02\u05EC\u05EE\x05\xE4s\x02\u05ED\u05EA" + + "\x03\x02\x02\x02\u05ED\u05EE\x03\x02\x02\x02\u05EE\u05F1\x03\x02\x02\x02" + + "\u05EF\u05F0\x07\x1A\x02\x02\u05F0\u05F2\x05\u013A\x9E\x02\u05F1\u05EF" + + "\x03\x02\x02\x02\u05F1\u05F2\x03\x02\x02\x02\u05F2\u05FD\x03\x02\x02\x02" + + "\u05F3\u05F4\x07 \x02\x02\u05F4\u05F5\x07`\x02\x02\u05F5\u05FA\x05\u0160" + + "\xB1\x02\u05F6\u05F7\x07\xD9\x02\x02\u05F7\u05F8\x07\x98\x02\x02\u05F8" + + "\u05F9\x07\xE8\x02\x02\u05F9\u05FB\x07\u0104\x02\x02\u05FA\u05F6\x03\x02" + + "\x02\x02\u05FA\u05FB\x03\x02\x02\x02\u05FB\u05FE\x03\x02\x02\x02\u05FC" + + "\u05FE\x07\xC7\x02\x02\u05FD\u05F3\x03\x02\x02\x02\u05FD\u05FC\x03\x02" + + "\x02\x02\u05FD\u05FE\x03\x02\x02\x02\u05FE\u0601\x03\x02\x02\x02\u05FF" + + "\u0600\x07\x1B\x02\x02\u0600\u0602\x05\xF6|\x02\u0601\u05FF\x03\x02\x02" + + "\x02\u0601\u0602\x03\x02\x02\x02\u0602\xC5\x03\x02\x02\x02\u0603\u0608" + + "\x05\xC8e\x02\u0604\u0605\x07\xF6\x02\x02\u0605\u0607\x05\xC8e\x02\u0606" + + "\u0604\x03\x02\x02\x02\u0607\u060A\x03\x02\x02\x02\u0608\u0606\x03\x02" + + "\x02\x02\u0608\u0609\x03\x02\x02\x02\u0609\xC7\x03\x02\x02\x02\u060A\u0608" + + "\x03\x02\x02\x02\u060B\u060C\x05\u0160\xB1\x02\u060C\u060D\x07\xE8\x02" + + "\x02\u060D\u060E\x05\u0130\x99\x02\u060E\xC9\x03\x02\x02\x02\u060F\u0610" + + "\x07\xF8\x02\x02\u0610\u0613\x05\xC0a\x02\u0611\u0612\x07$\x02\x02\u0612" + + "\u0614\x05\u013A\x9E\x02\u0613\u0611\x03\x02\x02\x02\u0613\u0614\x03\x02" + + "\x02\x02\u0614\u061D\x03\x02\x02\x02\u0615\u0616\x07\xF6\x02\x02\u0616" + + "\u0619\x05\u0164\xB3\x02\u0617\u0618\x07$\x02\x02\u0618\u061A\x05\u013A" + + "\x9E\x02\u0619\u0617\x03\x02\x02\x02\u0619\u061A\x03\x02\x02\x02\u061A" + + "\u061C\x03\x02\x02\x02\u061B\u0615\x03\x02\x02\x02\u061C\u061F\x03\x02" + + "\x02\x02\u061D\u061B\x03\x02\x02\x02\u061D\u061E\x03\x02\x02\x02\u061E" + + "\u0620\x03\x02\x02\x02\u061F\u061D\x03\x02\x02\x02\u0620\u0621\x07\xF9" + + "\x02\x02\u0621\xCB\x03\x02\x02\x02\u0622\u0624\x05\xCEh\x02\u0623\u0622" + + "\x03\x02\x02\x02\u0623\u0624\x03\x02\x02\x02\u0624\u0625\x03\x02\x02\x02" + + "\u0625\u0626\x05\u0100\x81\x02\u0626\xCD\x03\x02\x02\x02\u0627\u0628\x07" + + "\xD9\x02\x02\u0628\u062D\x05\u0110\x89\x02\u0629\u062A\x07\xF6\x02\x02" + + "\u062A\u062C\x05\u0110\x89\x02\u062B\u0629\x03\x02\x02\x02\u062C\u062F" + + "\x03\x02\x02\x02\u062D\u062B\x03\x02\x02\x02\u062D\u062E\x03\x02\x02\x02" + + "\u062E\xCF\x03\x02\x02\x02\u062F\u062D\x03\x02\x02\x02\u0630\u0631\x07" + + "\x97\x02\x02\u0631\u0632\x07n\x02\x02\u0632\u0634\x05\u0122\x92\x02\u0633" + + "\u0635\x077\x02\x02\u0634\u0633\x03\x02\x02\x02\u0634\u0635\x03\x02\x02" + + "\x02\u0635\u0639\x03\x02\x02\x02\u0636\u063A\x07\xE2\x02\x02\u0637\u0638" + + "\x07\xF6\x02\x02\u0638\u063A\x07\xE2\x02\x02\u0639\u0636\x03\x02\x02\x02" + + "\u0639\u0637\x03\x02\x02\x02\u0639\u063A\x03\x02\x02\x02\u063A\u063E\x03" + + "\x02\x02\x02\u063B\u063F\x07\xE3\x02\x02\u063C\u063D\x07\xF6\x02\x02\u063D" + + "\u063F\x07\xE3\x02\x02\u063E\u063B\x03\x02\x02\x02\u063E\u063C\x03\x02" + + "\x02\x02\u063E\u063F\x03\x02\x02\x02\u063F\u064C\x03\x02\x02\x02\u0640" + + "\u0641\x07\xF6\x02\x02\u0641\u0644\x05\xD2j\x02\u0642\u0644\x05\xD2j\x02" + + "\u0643\u0640\x03\x02\x02\x02\u0643\u0642\x03\x02\x02\x02\u0644\u0649\x03" + + "\x02\x02\x02\u0645\u0646\x07\xF6\x02\x02\u0646\u0648\x05\xD2j\x02\u0647" + + "\u0645\x03\x02\x02\x02\u0648\u064B\x03\x02\x02\x02\u0649\u064A\x03\x02" + + "\x02\x02\u0649\u0647\x03\x02\x02\x02\u064A\u064D\x03\x02\x02\x02\u064B" + + "\u0649\x03\x02\x02\x02\u064C\u0643\x03\x02\x02\x02\u064C\u064D\x03\x02" + + "\x02\x02\u064D\xD1\x03\x02\x02\x02\u064E\u064F\x07S\x02\x02\u064F\u0650" + + "\x07n\x02\x02\u0650\u0651\x05\u0122\x92\x02\u0651\u0652\x07\xE1\x02\x02" + + "\u0652\u0653\x05\xBA^\x02\u0653\u0655\x05\u0122\x92\x02\u0654\u0656\x07" + + "7\x02\x02\u0655\u0654\x03\x02\x02\x02\u0655\u0656\x03\x02\x02\x02\u0656" + + "\u0658\x03\x02\x02\x02\u0657\u0659\x07\xE2\x02\x02\u0658\u0657\x03\x02" + + "\x02\x02\u0658\u0659\x03\x02\x02\x02\u0659\u065B\x03\x02\x02\x02\u065A" + + "\u065C\x07\xE3\x02\x02\u065B\u065A\x03\x02\x02\x02\u065B\u065C\x03\x02" + + "\x02\x02\u065C\xD3\x03\x02\x02\x02\u065D\u065E\x05\xB6\\\x02\u065E\u0661" + + "\x05\u0148\xA5\x02\u065F\u0660\x07$\x02\x02\u0660\u0662\x05\u013A\x9E" + + "\x02\u0661\u065F\x03\x02\x02\x02\u0661\u0662\x03\x02\x02\x02\u0662\xD5" + + "\x03\x02\x02\x02\u0663\u0664\x05\xD8m\x02\u0664\xD7\x03\x02\x02\x02\u0665" + + "\u0666\x05\xB6\\\x02\u0666\u066E\x05\u0148\xA5\x02\u0667\u066B\x05\xDE" + + "p\x02\u0668\u066A\x05\xDEp\x02\u0669\u0668\x03\x02\x02\x02\u066A\u066D" + + "\x03\x02\x02\x02\u066B\u066C\x03\x02\x02\x02\u066B\u0669\x03\x02\x02\x02" + + "\u066C\u066F\x03\x02\x02\x02\u066D\u066B\x03\x02\x02\x02\u066E\u0667\x03" + + "\x02\x02\x02\u066E\u066F\x03\x02\x02\x02\u066F\u0672\x03\x02\x02\x02\u0670" + + "\u0671\x07$\x02\x02\u0671\u0673\x05\u013A\x9E\x02\u0672\u0670\x03\x02" + + "\x02\x02\u0672\u0673\x03\x02\x02\x02\u0673\u0676\x03\x02\x02\x02\u0674" + + "\u0675\x07\x97\x02\x02\u0675\u0677\x07n\x02\x02\u0676\u0674\x03\x02\x02" + + "\x02\u0676\u0677\x03\x02\x02\x02\u0677\xD9\x03\x02\x02\x02\u0678\u0679" + + "\x05\xC0a\x02\u0679\u067C\x05\u0148\xA5\x02\u067A\u067B\x07$\x02\x02\u067B" + + "\u067D\x05\u013A\x9E\x02\u067C\u067A\x03\x02\x02\x02\u067C\u067D\x03\x02" + + "\x02\x02\u067D\u0685\x03\x02\x02\x02\u067E\u0682\x05\xDEp\x02\u067F\u0681" + + "\x05\xDEp\x02\u0680\u067F\x03\x02\x02\x02\u0681\u0684\x03\x02\x02\x02" + + "\u0682\u0683\x03\x02\x02\x02\u0682\u0680\x03\x02\x02\x02\u0683\u0686\x03" + + "\x02\x02\x02\u0684\u0682\x03\x02\x02\x02\u0685\u067E\x03\x02\x02\x02\u0685" + + "\u0686\x03\x02\x02\x02\u0686\xDB\x03\x02\x02\x02\u0687\u0688\x05\xB6\\" + + "\x02\u0688\u068B\x05\u0148\xA5\x02\u0689\u068A\x07$\x02\x02\u068A\u068C" + + "\x05\u013A\x9E\x02\u068B\u0689\x03\x02\x02\x02\u068B\u068C\x03\x02\x02" + + "\x02\u068C\u0694\x03\x02\x02\x02\u068D\u0691\x05\xDEp\x02\u068E\u0690" + + "\x05\xDEp\x02\u068F\u068E\x03\x02\x02\x02\u0690\u0693\x03\x02\x02\x02" + + "\u0691\u0692\x03\x02\x02\x02\u0691\u068F\x03\x02\x02\x02\u0692\u0695\x03" + + "\x02\x02\x02\u0693\u0691\x03\x02\x02\x02\u0694\u068D\x03\x02\x02\x02\u0694" + + "\u0695\x03\x02\x02\x02\u0695\xDD\x03\x02\x02\x02\u0696\u0698\x07\x85\x02" + + "\x02\u0697\u0696\x03\x02\x02\x02\u0697\u0698\x03\x02\x02\x02\u0698\u0699" + + "\x03\x02\x02\x02\u0699\u069C\x07\x86\x02\x02\u069A\u069C\x05\xE0q\x02" + + "\u069B\u0697\x03\x02\x02\x02\u069B\u069A\x03\x02\x02\x02\u069C\xDF\x03" + + "\x02\x02\x02\u069D\u069E\x07>\x02\x02\u069E\u06A6\x05\u0130\x99\x02\u069F" + + "\u06A0\x07%\x02\x02\u06A0\u06A6\x05\u0130\x99\x02\u06A1\u06A2\x075\x02" + + "\x02\u06A2\u06A6\x05\u0130\x99\x02\u06A3\u06A4\x07\x12\x02\x02\u06A4\u06A6" + + "\x05\u0166\xB4\x02\u06A5\u069D\x03\x02\x02\x02\u06A5\u069F\x03\x02\x02" + + "\x02\u06A5\u06A1\x03\x02\x02\x02\u06A5\u06A3\x03\x02\x02\x02\u06A6\xE1" + + "\x03\x02\x02\x02\u06A7\u06A8\t\f\x02\x02\u06A8\xE3\x03\x02\x02\x02\u06A9" + + "\u06AA\t\r\x02\x02\u06AA\xE5\x03\x02\x02\x02\u06AB\u06B0\x05\xE8u\x02" + + "\u06AC\u06AD\x07\xF6\x02\x02\u06AD\u06AF\x05\xE8u\x02\u06AE\u06AC\x03" + + "\x02\x02\x02\u06AF\u06B2\x03\x02\x02\x02\u06B0\u06B1\x03\x02\x02\x02\u06B0" + + "\u06AE\x03\x02\x02\x02\u06B1\u06B5\x03\x02\x02\x02\u06B2\u06B0\x03\x02" + + "\x02\x02\u06B3\u06B4\x07\xF6\x02\x02\u06B4\u06B6\x05\xEAv\x02\u06B5\u06B3" + + "\x03\x02\x02\x02\u06B5\u06B6\x03\x02\x02\x02\u06B6\u06B9\x03\x02\x02\x02" + + "\u06B7\u06B9\x05\xEAv\x02\u06B8\u06AB\x03\x02\x02\x02\u06B8\u06B7\x03" + + "\x02\x02\x02\u06B9\xE7\x03\x02\x02\x02\u06BA\u06BC\x07[\x02\x02\u06BB" + + "\u06BD\x05\u0122\x92\x02\u06BC\u06BB\x03\x02\x02\x02\u06BC\u06BD\x03\x02" + + "\x02\x02\u06BD\u06BE\x03\x02\x02\x02\u06BE\u06BF\x07\x93\x02\x02\u06BF" + + "\u06C0\x05\u0166\xB4\x02\u06C0\xE9\x03\x02\x02\x02\u06C1\u06C3\x07\x9B" + + "\x02\x02\u06C2\u06C4\x05\u0122\x92\x02\u06C3\u06C2\x03\x02\x02\x02\u06C3" + + "\u06C4\x03\x02\x02\x02\u06C4\u06C5\x03\x02\x02\x02\u06C5\u06C6\x07\xF8" + + "\x02\x02\u06C6\u06C7\x07\x92\x02\x02\u06C7\u06CD\x05\xECw\x02\u06C8\u06C9" + + "\x07\xF6\x02\x02\u06C9\u06CA\x07\x92\x02\x02\u06CA\u06CC\x05\xECw\x02" + + "\u06CB\u06C8\x03\x02\x02\x02\u06CC\u06CF\x03\x02\x02\x02\u06CD\u06CE\x03" + + "\x02\x02\x02\u06CD\u06CB\x03\x02\x02\x02\u06CE\u06D0\x03\x02\x02\x02\u06CF" + + "\u06CD\x03\x02\x02\x02\u06D0\u06D1\x07\xF9\x02\x02\u06D1\xEB\x03\x02\x02" + + "\x02\u06D2\u06D3\x07\xD3\x02\x02\u06D3\u06D4\x05\xF2z\x02\u06D4\u06D5" + + "\x05\u0130\x99\x02\u06D5\u06E2\x03\x02\x02\x02\u06D6\u06D7\x05\u0130\x99" + + "\x02\u06D7\u06D8\x05\xF0y\x02\u06D8\u06DA\x03\x02\x02\x02\u06D9\u06D6" + + "\x03\x02\x02\x02\u06D9\u06DA\x03\x02\x02\x02\u06DA\u06DB\x03\x02\x02\x02" + + "\u06DB\u06DF\x07\xD4\x02\x02\u06DC\u06DD\x05\xF0y\x02\u06DD\u06DE\x05" + + "\u0130\x99\x02\u06DE\u06E0\x03\x02\x02\x02\u06DF\u06DC\x03\x02\x02\x02" + + "\u06DF\u06E0\x03\x02\x02\x02\u06E0\u06E2\x03\x02\x02\x02\u06E1\u06D2\x03" + + "\x02\x02\x02\u06E1\u06D9\x03\x02\x02\x02\u06E2\xED\x03\x02\x02\x02\u06E3" + + "\u06E4\x07 \x02\x02\u06E4\u06E5\x07`\x02\x02\u06E5\u06EA\x05\u0164\xB3" + + "\x02\u06E6\u06E7\x07\xD9\x02\x02\u06E7\u06E8\x07\x98\x02\x02\u06E8\u06E9" + + "\x07\xE8\x02\x02\u06E9\u06EB\x05\u0166\xB4\x02\u06EA\u06E6\x03\x02\x02" + + "\x02\u06EA\u06EB\x03\x02\x02\x02\u06EB\u06EE\x03\x02\x02\x02\u06EC\u06EE" + + "\x07\xC7\x02\x02\u06ED\u06E3\x03\x02\x02\x02\u06ED\u06EC\x03\x02\x02\x02" + + "\u06EE\xEF\x03\x02\x02\x02\u06EF\u06F5\x03\x02\x02\x02\u06F0\u06F5\x07" + + "\xEA\x02\x02\u06F1\u06F5\x07\xEB\x02\x02\u06F2\u06F5\x07\xEC\x02\x02\u06F3" + + "\u06F5\x07\xED\x02\x02\u06F4\u06EF\x03\x02\x02\x02\u06F4\u06F0\x03\x02" + + "\x02\x02\u06F4\u06F1\x03\x02\x02\x02\u06F4\u06F2\x03\x02\x02\x02\u06F4" + + "\u06F3\x03\x02\x02\x02\u06F5\xF1\x03\x02\x02\x02\u06F6\u06FF\x07\xE8\x02" + + "\x02\u06F7\u06FF\x07\xE9\x02\x02\u06F8\u06FF\x07s\x02\x02\u06F9\u06FF" + + "\x07\xA5\x02\x02\u06FA\u06FF\x07\xA4\x02\x02\u06FB\u06FF\x07\x11\x02\x02" + + "\u06FC\u06FF\x07`\x02\x02\u06FD\u06FF\x05\xF0y\x02\u06FE\u06F6\x03\x02" + + "\x02\x02\u06FE\u06F7\x03\x02\x02\x02\u06FE\u06F8\x03\x02\x02\x02\u06FE" + + "\u06F9\x03\x02\x02\x02\u06FE\u06FA\x03\x02\x02\x02\u06FE\u06FB\x03\x02" + + "\x02\x02\u06FE\u06FC\x03\x02\x02\x02\u06FE\u06FD\x03\x02\x02\x02\u06FF" + + "\xF3\x03\x02\x02\x02\u0700\u0701\x07s\x02\x02\u0701\u0704\x05\u0160\xB1" + + "\x02\u0702\u0703\t\x0E\x02\x02\u0703\u0705\x07\x9A\x02\x02\u0704\u0702" + + "\x03\x02\x02\x02\u0704\u0705\x03\x02\x02\x02\u0705\xF5\x03\x02\x02\x02" + + "\u0706\u0707\x07\xF8\x02\x02\u0707\u070C\x05\xFE\x80\x02\u0708\u0709\x07" + + "\xF6\x02\x02\u0709\u070B\x05\xFE\x80\x02\u070A\u0708\x03\x02\x02\x02\u070B" + + "\u070E\x03\x02\x02\x02\u070C\u070A\x03\x02\x02\x02\u070C\u070D\x03\x02" + + "\x02\x02\u070D\u070F\x03\x02\x02\x02\u070E\u070C\x03\x02\x02\x02\u070F" + + "\u0710\x07\xF9\x02\x02\u0710\xF7\x03\x02\x02\x02\u0711\u0712\x07\xF8\x02" + + "\x02\u0712\u0717\x05\xD4k\x02\u0713\u0714\x07\xF6\x02\x02\u0714\u0716" + + "\x05\xD4k\x02\u0715\u0713\x03\x02\x02\x02\u0716\u0719\x03\x02\x02\x02" + + "\u0717\u0718\x03\x02\x02\x02\u0717\u0715\x03\x02\x02\x02\u0718\u071A\x03" + + "\x02\x02\x02\u0719\u0717\x03\x02\x02\x02\u071A\u071B\x07\xF9\x02\x02\u071B" + + "\xF9\x03\x02\x02\x02\u071C\u0721\x05\u0130\x99\x02\u071D\u071E\x07\xF6" + + "\x02\x02\u071E\u0720\x05\u0130\x99\x02\u071F\u071D\x03\x02\x02\x02\u0720" + + "\u0723\x03\x02\x02\x02\u0721\u071F\x03\x02\x02\x02\u0721\u0722\x03\x02" + + "\x02\x02\u0722\xFB\x03\x02\x02\x02\u0723\u0721\x03\x02\x02\x02\u0724\u072E" + + "\x076\x02\x02\u0725\u0726\x07I\x02\x02\u0726\u0727\x07\xC1\x02\x02\u0727" + + "\u0728\x07\x1C\x02\x02\u0728\u072C\x05\u013A\x9E\x02\u0729\u072A\x07A" + + "\x02\x02\u072A\u072B\x07\x1C\x02\x02\u072B\u072D\x05\u013A\x9E\x02\u072C" + + "\u0729\x03\x02\x02\x02\u072C\u072D\x03\x02\x02\x02\u072D\u072F\x03\x02" + + "\x02\x02\u072E\u0725\x03\x02\x02\x02\u072E\u072F\x03\x02\x02\x02\u072F" + + "\u0734\x03\x02\x02\x02\u0730\u0731\x07u\x02\x02\u0731\u0732\x07\xC1\x02" + + "\x02\u0732\u0733\x07\x1C\x02\x02\u0733\u0735\x05\u013A\x9E\x02\u0734\u0730" + + "\x03\x02\x02\x02\u0734\u0735\x03\x02\x02\x02\u0735\xFD\x03\x02\x02\x02" + + "\u0736\u0739\x05\u0164\xB3\x02\u0737\u0738\x07\xE8\x02\x02\u0738\u073A" + + "\x05\u0130\x99\x02\u0739\u0737\x03\x02\x02\x02\u0739\u073A\x03\x02\x02" + + "\x02\u073A\xFF\x03\x02\x02\x02\u073B\u0746\x05\u0102\x82\x02\u073C\u073D" + + "\x07\x8C\x02\x02\u073D\u073E\x07\x1C\x02\x02\u073E\u0743\x05\u0106\x84" + + "\x02\u073F\u0740\x07\xF6\x02\x02\u0740\u0742\x05\u0106\x84\x02\u0741\u073F" + + "\x03\x02\x02\x02\u0742\u0745\x03\x02\x02\x02\u0743\u0741\x03\x02\x02\x02" + + "\u0743\u0744\x03\x02\x02\x02\u0744\u0747\x03\x02\x02\x02\u0745\u0743\x03" + + "\x02\x02\x02\u0746\u073C\x03\x02\x02\x02\u0746\u0747\x03\x02\x02\x02\u0747" + + "\u074E\x03\x02\x02\x02\u0748\u0749\x07t\x02\x02\u0749\u074C\x05\u0130" + + "\x99\x02\u074A\u074B\x07\x88\x02\x02\u074B\u074D\x07\u0104\x02\x02\u074C" + + "\u074A\x03\x02\x02\x02\u074C\u074D\x03\x02\x02\x02\u074D\u074F\x03\x02" + + "\x02\x02\u074E\u0748\x03\x02\x02\x02\u074E\u074F\x03\x02\x02\x02\u074F" + + "\u0101\x03\x02\x02\x02\u0750\u0751\b\x82\x01\x02\u0751\u0752\x05\u0104" + + "\x83\x02\u0752\u0761\x03\x02\x02\x02\u0753\u0754\f\x04\x02\x02\u0754\u0756" + + "\x07f\x02\x02\u0755\u0757\x05\u0112\x8A\x02\u0756\u0755\x03\x02\x02\x02" + + "\u0756\u0757\x03\x02\x02\x02\u0757\u0758\x03\x02\x02\x02\u0758\u0760\x05" + + "\u0102\x82\x05\u0759\u075A\f\x03\x02\x02\u075A\u075C\t\x0F\x02\x02\u075B" + + "\u075D\x05\u0112\x8A\x02\u075C\u075B\x03\x02\x02\x02\u075C\u075D\x03\x02" + + "\x02\x02\u075D\u075E\x03\x02\x02\x02\u075E\u0760\x05\u0102\x82\x04\u075F" + + "\u0753\x03\x02\x02\x02\u075F\u0759\x03\x02\x02\x02\u0760\u0763\x03\x02" + + "\x02\x02\u0761\u075F\x03\x02\x02\x02\u0761\u0762\x03\x02\x02\x02\u0762" + + "\u0103\x03\x02\x02\x02\u0763\u0761\x03\x02\x02\x02\u0764\u0775\x05\u0108" + + "\x85\x02\u0765\u0766\x07\xBE\x02\x02\u0766\u0775\x05\xBA^\x02\u0767\u0768" + + "\x07\xD4\x02\x02\u0768\u076D\x05\u0130\x99\x02\u0769\u076A\x07\xF6\x02" + + "\x02\u076A\u076C\x05\u0130\x99\x02\u076B\u0769\x03\x02\x02\x02\u076C\u076F" + + "\x03\x02\x02\x02\u076D\u076B\x03\x02\x02\x02\u076D\u076E\x03\x02\x02\x02" + + "\u076E\u0775\x03\x02\x02\x02\u076F\u076D\x03\x02\x02\x02\u0770\u0771\x07" + + "\xF8\x02\x02\u0771\u0772\x05\u0100\x81\x02\u0772\u0773\x07\xF9\x02\x02" + + "\u0773\u0775\x03\x02\x02\x02\u0774\u0764\x03\x02\x02\x02\u0774\u0765\x03" + + "\x02\x02\x02\u0774\u0767\x03\x02\x02\x02\u0774\u0770\x03\x02\x02\x02\u0775" + + "\u0105\x03\x02\x02\x02\u0776\u0778\x05\u012E\x98\x02\u0777\u0779\t\x10" + + "\x02\x02\u0778\u0777\x03\x02\x02\x02\u0778\u0779\x03\x02\x02\x02\u0779" + + "\u077C\x03\x02\x02\x02\u077A\u077B\x07\x87\x02\x02\u077B\u077D\t\x11\x02" + + "\x02\u077C\u077A\x03\x02\x02\x02\u077C\u077D\x03\x02\x02\x02\u077D\u0107" + + "\x03\x02\x02\x02\u077E\u0780\x07\xAF\x02\x02\u077F\u0781\x05\u0112\x8A" + + "\x02\u0780\u077F\x03\x02\x02\x02\u0780\u0781\x03\x02\x02\x02\u0781\u0783" + + "\x03\x02\x02\x02\u0782\u0784\x07\xB9\x02\x02\u0783\u0782\x03\x02\x02\x02" + + "\u0783\u0784\x03\x02\x02\x02\u0784\u0785\x03\x02\x02\x02\u0785\u078A\x05" + + "\u0114\x8B\x02\u0786\u0787\x07\xF6\x02\x02\u0787\u0789\x05\u0114\x8B\x02" + + "\u0788\u0786\x03\x02\x02\x02\u0789\u078C\x03\x02\x02\x02\u078A\u0788\x03" + + "\x02\x02\x02\u078A\u078B\x03\x02\x02\x02\u078B\u0796\x03\x02\x02\x02\u078C" + + "\u078A\x03\x02\x02\x02\u078D\u078E\x07T\x02\x02\u078E\u0793\x05\u0116" + + "\x8C\x02\u078F\u0790\x07\xF6\x02\x02\u0790\u0792\x05\u0116\x8C\x02\u0791" + + "\u078F\x03\x02\x02\x02\u0792\u0795\x03\x02\x02\x02\u0793\u0791\x03\x02" + + "\x02\x02\u0793\u0794\x03\x02\x02\x02\u0794\u0797\x03\x02\x02\x02\u0795" + + "\u0793\x03\x02\x02\x02\u0796\u078D\x03\x02\x02\x02\u0796\u0797\x03\x02" + + "\x02\x02\u0797\u079A\x03\x02\x02\x02\u0798\u0799\x07\xD8\x02\x02\u0799" + + "\u079B\x05\u0132\x9A\x02\u079A\u0798\x03\x02\x02\x02\u079A\u079B\x03\x02" + + "\x02\x02\u079B\u079F\x03\x02\x02\x02\u079C\u079D\x07Y\x02\x02\u079D\u079E" + + "\x07\x1C\x02\x02\u079E\u07A0\x05\u010A\x86\x02\u079F\u079C\x03\x02\x02" + + "\x02\u079F\u07A0\x03\x02\x02\x02\u07A0\u07A3\x03\x02\x02\x02\u07A1\u07A2" + + "\x07\\\x02\x02\u07A2\u07A4\x05\u0132\x9A\x02\u07A3\u07A1\x03\x02\x02\x02" + + "\u07A3\u07A4\x03\x02\x02\x02\u07A4\u0109\x03\x02\x02\x02\u07A5\u07A7\x05" + + "\u0112\x8A\x02\u07A6\u07A5\x03\x02\x02\x02\u07A6\u07A7\x03\x02\x02\x02" + + "\u07A7\u07A8\x03\x02\x02\x02\u07A8\u07AD\x05\u010C\x87\x02\u07A9\u07AA" + + "\x07\xF6\x02\x02\u07AA\u07AC\x05\u010C\x87\x02\u07AB\u07A9\x03\x02\x02" + + "\x02\u07AC\u07AF\x03\x02\x02\x02\u07AD\u07AB\x03\x02\x02\x02\u07AD\u07AE" + + "\x03\x02\x02\x02\u07AE\u010B\x03\x02\x02\x02\u07AF\u07AD\x03\x02\x02\x02" + + "\u07B0\u07B1\x05\u010E\x88\x02\u07B1\u010D\x03\x02\x02\x02\u07B2\u07BB" + + "\x07\xF8\x02\x02\u07B3\u07B8\x05\u012E\x98\x02\u07B4\u07B5\x07\xF6\x02" + + "\x02\u07B5\u07B7\x05\u012E\x98\x02\u07B6\u07B4\x03\x02\x02\x02\u07B7\u07BA" + + "\x03\x02\x02\x02\u07B8\u07B6\x03\x02\x02\x02\u07B8\u07B9\x03\x02\x02\x02" + + "\u07B9\u07BC\x03\x02\x02\x02\u07BA\u07B8\x03\x02\x02\x02\u07BB\u07B3\x03" + + "\x02\x02\x02\u07BB\u07BC\x03\x02\x02\x02\u07BC\u07BD\x03\x02\x02\x02\u07BD" + + "\u07C0\x07\xF9\x02\x02\u07BE\u07C0\x05\u012E\x98\x02\u07BF\u07B2\x03\x02" + + "\x02\x02\u07BF\u07BE\x03\x02\x02\x02\u07C0\u010F\x03\x02\x02\x02\u07C1" + + "\u07C3\x05\u0164\xB3\x02\u07C2\u07C4\x05\u0122\x92\x02\u07C3\u07C2\x03" + + "\x02\x02\x02\u07C3\u07C4\x03\x02\x02\x02\u07C4\u07C5\x03\x02\x02\x02\u07C5" + + "\u07C6\x07\v\x02\x02\u07C6\u07C7\x05\u0128\x95\x02\u07C7\u0111\x03\x02" + + "\x02\x02\u07C8\u07C9\t\x12\x02\x02\u07C9\u0113\x03\x02\x02\x02\u07CA\u07CF" + + "\x05\u012E\x98\x02\u07CB\u07CD\x07\v\x02\x02\u07CC\u07CB\x03\x02\x02\x02" + + "\u07CC\u07CD\x03\x02\x02\x02\u07CD\u07CE\x03\x02\x02\x02\u07CE\u07D0\x05" + + "\u0164\xB3\x02\u07CF\u07CC\x03\x02\x02\x02\u07CF\u07D0\x03\x02\x02\x02" + + "\u07D0\u07D7\x03\x02\x02\x02\u07D1\u07D2\x05\u0160\xB1\x02\u07D2\u07D3" + + "\x07\xF4\x02\x02\u07D3\u07D4\x07\xF0\x02\x02\u07D4\u07D7\x03\x02\x02\x02" + + "\u07D5\u07D7\x07\xF0\x02\x02\u07D6\u07CA\x03\x02\x02\x02\u07D6\u07D1\x03" + + "\x02\x02\x02\u07D6\u07D5\x03\x02\x02\x02\u07D7\u0115\x03\x02\x02\x02\u07D8" + + "\u07D9\b\x8C\x01\x02\u07D9\u07DA\x05\u011C\x8F\x02\u07DA\u07E8\x03\x02" + + "\x02\x02\u07DB\u07E4\f\x04\x02\x02\u07DC\u07DD\x07(\x02\x02\u07DD\u07DE" + + "\x07m\x02\x02\u07DE\u07E5\x05\u011C\x8F\x02\u07DF\u07E0\x05\u0118\x8D" + + "\x02\u07E0\u07E1\x07m\x02\x02\u07E1\u07E2\x05\u0116\x8C\x02\u07E2\u07E3" + + "\x05\u011A\x8E\x02\u07E3\u07E5\x03\x02\x02\x02\u07E4\u07DC\x03\x02\x02" + + "\x02\u07E4\u07DF\x03\x02\x02\x02\u07E5\u07E7\x03\x02\x02\x02\u07E6\u07DB" + + "\x03\x02\x02\x02\u07E7\u07EA\x03\x02\x02\x02\u07E8\u07E6\x03\x02\x02\x02" + + "\u07E8\u07E9\x03\x02\x02\x02\u07E9\u0117\x03\x02\x02\x02\u07EA\u07E8\x03" + + "\x02\x02\x02\u07EB\u07ED\x07c\x02\x02\u07EC\u07EB\x03\x02\x02\x02\u07EC" + + "\u07ED\x03\x02\x02\x02\u07ED\u080B\x03\x02\x02\x02\u07EE\u07F0\x07r\x02" + + "\x02\u07EF\u07F1\x07c\x02\x02\u07F0\u07EF\x03\x02\x02\x02\u07F0\u07F1" + + "\x03\x02\x02\x02\u07F1\u080B\x03\x02\x02\x02\u07F2\u07F4\x07\xA6\x02\x02" + + "\u07F3\u07F5\x07c\x02\x02\u07F4\u07F3\x03\x02\x02\x02\u07F4\u07F5\x03" + + "\x02\x02\x02\u07F5\u080B\x03\x02\x02\x02\u07F6\u07F8\x07r\x02\x02\u07F7" + + "\u07F9\x07\x8E\x02\x02\u07F8\u07F7\x03\x02\x02\x02\u07F8\u07F9\x03\x02" + + "\x02\x02\u07F9\u080B\x03\x02\x02\x02\u07FA\u07FC\x07\xA6\x02\x02\u07FB" + + "\u07FD\x07\x8E\x02\x02\u07FC\u07FB\x03\x02\x02\x02\u07FC\u07FD\x03\x02" + + "\x02\x02\u07FD\u080B\x03\x02\x02\x02\u07FE\u0800\x07U\x02\x02\u07FF\u0801" + + "\x07\x8E\x02\x02\u0800\u07FF\x03\x02\x02\x02\u0800\u0801\x03\x02\x02\x02" + + "\u0801\u080B\x03\x02\x02\x02\u0802\u0803\x07r\x02\x02\u0803\u080B\x07" + + "\xB2\x02\x02\u0804\u0805\x07\xA6\x02\x02\u0805\u080B\x07\xB2\x02\x02\u0806" + + "\u0807\x07r\x02\x02\u0807\u080B\x07\t\x02\x02\u0808\u0809\x07\xA6\x02" + + "\x02\u0809\u080B\x07\t\x02\x02\u080A\u07EC\x03\x02\x02\x02\u080A\u07EE" + + "\x03\x02\x02\x02\u080A\u07F2\x03\x02\x02\x02\u080A\u07F6\x03\x02\x02\x02" + + "\u080A\u07FA\x03\x02\x02\x02\u080A\u07FE\x03\x02\x02\x02\u080A\u0802\x03" + + "\x02\x02\x02\u080A\u0804\x03\x02\x02\x02\u080A\u0806\x03\x02\x02\x02\u080A" + + "\u0808\x03\x02\x02\x02\u080B\u0119\x03\x02\x02\x02\u080C\u080D\x07\x89" + + "\x02\x02\u080D\u081B\x05\u0132\x9A\x02\u080E\u080F\x07\xCF\x02\x02\u080F" + + "\u0810\x07\xF8\x02\x02\u0810\u0815\x05\u0164\xB3\x02\u0811\u0812\x07\xF6" + + "\x02\x02\u0812\u0814\x05\u0164\xB3\x02\u0813\u0811"; + private static readonly _serializedATNSegment4: string = + "\x03\x02\x02\x02\u0814\u0817\x03\x02\x02\x02\u0815\u0813\x03\x02\x02\x02" + + "\u0815\u0816\x03\x02\x02\x02\u0816\u0818\x03\x02\x02\x02\u0817\u0815\x03" + + "\x02\x02\x02\u0818\u0819\x07\xF9\x02\x02\u0819\u081B\x03\x02\x02\x02\u081A" + + "\u080C\x03\x02\x02\x02\u081A\u080E\x03\x02\x02\x02\u081B\u011B\x03\x02" + + "\x02\x02\u081C\u0829\x05\u0120\x91\x02\u081D\u081E\x07\xC0\x02\x02\u081E" + + "\u081F\x05\u011E\x90\x02\u081F\u0820\x07\xF8\x02\x02\u0820\u0821\x05\u0130" + + "\x99\x02\u0821\u0827\x07\xF9\x02\x02\u0822\u0823\x07\x9E\x02\x02\u0823" + + "\u0824\x07\xF8\x02\x02\u0824\u0825\x05\u0130\x99\x02\u0825\u0826\x07\xF9" + + "\x02\x02\u0826\u0828\x03\x02\x02\x02\u0827\u0822\x03\x02\x02\x02\u0827" + + "\u0828\x03\x02\x02\x02\u0828\u082A\x03\x02\x02\x02\u0829\u081D\x03\x02" + + "\x02\x02\u0829\u082A\x03\x02\x02\x02\u082A\u011D\x03\x02\x02\x02\u082B" + + "\u082C\t\x13\x02\x02\u082C\u011F\x03\x02\x02\x02\u082D\u0835\x05\u0126" + + "\x94\x02\u082E\u0830\x07\v\x02\x02\u082F\u082E\x03\x02\x02\x02\u082F\u0830" + + "\x03\x02\x02\x02\u0830\u0831\x03\x02\x02\x02\u0831\u0833\x05\u0164\xB3" + + "\x02\u0832\u0834\x05\u0122\x92\x02\u0833\u0832\x03\x02\x02\x02\u0833\u0834" + + "\x03\x02\x02\x02\u0834\u0836\x03\x02\x02\x02\u0835\u082F\x03\x02\x02\x02" + + "\u0835\u0836\x03\x02\x02\x02\u0836\u0121\x03\x02\x02\x02\u0837\u0838\x07" + + "\xF8\x02\x02\u0838\u083D\x05\xC0a\x02\u0839\u083A\x07\xF6\x02\x02\u083A" + + "\u083C\x05\xC0a\x02\u083B\u0839\x03\x02\x02\x02\u083C\u083F\x03\x02\x02" + + "\x02\u083D\u083B\x03\x02\x02\x02\u083D\u083E\x03\x02\x02\x02\u083E\u0840" + + "\x03\x02\x02\x02\u083F\u083D\x03\x02\x02\x02\u0840\u0841\x07\xF9\x02\x02" + + "\u0841\u0123\x03\x02\x02\x02\u0842\u0843\x07\xF8\x02\x02\u0843\u0848\x05" + + "\xC0a\x02\u0844\u0845\x07\xF6\x02\x02\u0845\u0847\x05\xC0a\x02\u0846\u0844" + + "\x03\x02\x02\x02\u0847\u084A\x03\x02\x02\x02\u0848\u0846\x03\x02\x02\x02" + + "\u0848\u0849\x03\x02\x02\x02\u0849\u084B\x03\x02\x02\x02\u084A\u0848\x03" + + "\x02\x02\x02\u084B\u084C\x07\xF9\x02\x02\u084C\u0125\x03\x02\x02\x02\u084D" + + "\u0855\x05\xC2b\x02\u084E\u0850\x07q\x02\x02\u084F\u084E\x03\x02\x02\x02" + + "\u084F\u0850\x03\x02\x02\x02\u0850\u0851\x03\x02\x02\x02\u0851\u0855\x05" + + "\u0128\x95\x02\u0852\u0855\x05\u012A\x96\x02\u0853\u0855\x05\u012C\x97" + + "\x02\u0854\u084D\x03\x02\x02\x02\u0854\u084F\x03\x02\x02\x02\u0854\u0852" + + "\x03\x02\x02\x02\u0854\u0853\x03\x02\x02\x02\u0855\u0127\x03\x02\x02\x02" + + "\u0856\u0857\x07\xF8\x02\x02\u0857\u0858\x05\xCCg\x02\u0858\u0859\x07" + + "\xF9\x02\x02\u0859\u0129\x03\x02\x02\x02\u085A\u085B\x07\xCB\x02\x02\u085B" + + "\u085C\x07\xF8\x02\x02\u085C\u0861\x05\u0130\x99\x02\u085D\u085E\x07\xF6" + + "\x02\x02\u085E\u0860\x05\u0130\x99\x02\u085F\u085D\x03\x02\x02\x02\u0860" + + "\u0863\x03\x02\x02\x02\u0861\u085F\x03\x02\x02\x02\u0861\u0862\x03\x02" + + "\x02\x02\u0862\u0864\x03\x02\x02\x02\u0863\u0861\x03\x02\x02\x02\u0864" + + "\u0867\x07\xF9\x02\x02\u0865\u0866\x07\xD9\x02\x02\u0866\u0868\x07\x8D" + + "\x02\x02\u0867\u0865\x03\x02\x02\x02\u0867\u0868\x03\x02\x02\x02\u0868" + + "\u012B\x03\x02\x02\x02\u0869\u086A\x07\xF8\x02\x02\u086A\u086B\x05\u0116" + + "\x8C\x02\u086B\u086C\x07\xF9\x02\x02\u086C\u012D\x03\x02\x02\x02\u086D" + + "\u0870\x05\xC0a\x02\u086E\u0870\x05\u0130\x99\x02\u086F\u086D\x03\x02" + + "\x02\x02\u086F\u086E\x03\x02\x02\x02\u0870\u012F\x03\x02\x02\x02\u0871" + + "\u0872\x05\u0132\x9A\x02\u0872\u0131\x03\x02\x02\x02\u0873\u0874\b\x9A" + + "\x01\x02\u0874\u0876\x05\u0136\x9C\x02\u0875\u0877\x05\u0134\x9B\x02\u0876" + + "\u0875\x03\x02\x02\x02\u0876\u0877\x03\x02\x02\x02\u0877\u087B\x03\x02" + + "\x02\x02\u0878\u0879\x07\x85\x02\x02\u0879\u087B\x05\u0132\x9A\x05\u087A" + + "\u0873\x03\x02\x02\x02\u087A\u0878\x03\x02\x02\x02\u087B\u0884\x03\x02" + + "\x02\x02\u087C\u087D\f\x04\x02\x02\u087D\u087E\x07\x07\x02\x02\u087E\u0883" + + "\x05\u0132\x9A\x05\u087F\u0880\f\x03\x02\x02\u0880\u0881\x07\x8B\x02\x02" + + "\u0881\u0883\x05\u0132\x9A\x04\u0882\u087C\x03\x02\x02\x02\u0882\u087F" + + "\x03\x02\x02\x02\u0883\u0886\x03\x02\x02\x02\u0884\u0882\x03\x02\x02\x02" + + "\u0884\u0885\x03\x02\x02\x02\u0885\u0133\x03\x02\x02\x02\u0886\u0884\x03" + + "\x02\x02\x02\u0887\u0888\x05\u013C\x9F\x02\u0888\u0889\x05\u0136\x9C\x02" + + "\u0889\u08C2\x03\x02\x02\x02\u088A\u088B\x05\u013C\x9F\x02\u088B\u088C" + + "\x05\u013E\xA0\x02\u088C\u088D\x05\u0128\x95\x02\u088D\u08C2\x03\x02\x02" + + "\x02\u088E\u0890\x07\x85\x02\x02\u088F\u088E\x03\x02\x02\x02\u088F\u0890" + + "\x03\x02\x02\x02\u0890\u0891\x03\x02\x02\x02\u0891\u0892\x07\x11\x02\x02" + + "\u0892\u0893\x05\u0136\x9C\x02\u0893\u0894\x07\x07\x02\x02\u0894\u0895" + + "\x05\u0136\x9C\x02\u0895\u08C2\x03\x02\x02\x02\u0896\u0898\x07\x85\x02" + + "\x02\u0897\u0896\x03\x02\x02\x02\u0897\u0898\x03\x02\x02\x02\u0898\u0899" + + "\x03\x02\x02\x02\u0899\u089A\x07`\x02\x02\u089A\u089B\x07\xF8\x02\x02" + + "\u089B\u08A0\x05\u0130\x99\x02\u089C\u089D\x07\xF6\x02\x02\u089D\u089F" + + "\x05\u0130\x99\x02\u089E\u089C\x03\x02\x02\x02\u089F\u08A2\x03\x02\x02" + + "\x02\u08A0\u089E\x03\x02\x02\x02\u08A0\u08A1\x03\x02\x02\x02\u08A1\u08A3" + + "\x03\x02\x02\x02\u08A2\u08A0\x03\x02\x02\x02\u08A3\u08A4\x07\xF9\x02\x02" + + "\u08A4\u08C2\x03\x02\x02\x02\u08A5\u08A7\x07\x85\x02\x02\u08A6\u08A5\x03" + + "\x02\x02\x02\u08A6\u08A7\x03\x02\x02\x02\u08A7\u08A8\x03\x02\x02\x02\u08A8" + + "\u08A9\x07`\x02\x02\u08A9\u08C2\x05\u0128\x95\x02\u08AA\u08AC\x07\x85" + + "\x02\x02\u08AB\u08AA\x03\x02\x02\x02\u08AB\u08AC\x03\x02\x02\x02\u08AC" + + "\u08AD\x03\x02\x02\x02\u08AD\u08AE\x07s\x02\x02\u08AE\u08B1\x05\u0136" + + "\x9C\x02\u08AF\u08B0\x07@\x02\x02\u08B0\u08B2\x05\u0136\x9C\x02\u08B1" + + "\u08AF\x03\x02\x02\x02\u08B1\u08B2\x03\x02\x02\x02\u08B2\u08C2\x03\x02" + + "\x02\x02\u08B3\u08B4\x07\xA4\x02\x02\u08B4\u08C2\x05\u0136\x9C\x02\u08B5" + + "\u08B7\x07l\x02\x02\u08B6\u08B8\x07\x85\x02\x02\u08B7\u08B6\x03\x02\x02" + + "\x02\u08B7\u08B8\x03\x02\x02\x02\u08B8\u08B9\x03\x02\x02\x02\u08B9\u08C2" + + "\x07\x86\x02\x02\u08BA\u08BC\x07l\x02\x02\u08BB\u08BD\x07\x85\x02\x02" + + "\u08BC\u08BB\x03\x02\x02\x02\u08BC\u08BD\x03\x02\x02\x02\u08BD\u08BE\x03" + + "\x02\x02\x02\u08BE\u08BF\x07;\x02\x02\u08BF\u08C0\x07T\x02\x02\u08C0\u08C2" + + "\x05\u0136\x9C\x02\u08C1\u0887\x03\x02\x02\x02\u08C1\u088A\x03\x02\x02" + + "\x02\u08C1\u088F\x03\x02\x02\x02\u08C1\u0897\x03\x02\x02\x02\u08C1\u08A6" + + "\x03\x02\x02\x02\u08C1\u08AB\x03\x02\x02\x02\u08C1\u08B3\x03\x02\x02\x02" + + "\u08C1\u08B5\x03\x02\x02\x02\u08C1\u08BA\x03\x02\x02\x02\u08C2\u0135\x03" + + "\x02\x02\x02\u08C3\u08C4\b\x9C\x01\x02\u08C4\u08C8\x05\u0138\x9D\x02\u08C5" + + "\u08C6\t\x14\x02\x02\u08C6\u08C8\x05\u0136\x9C\x06\u08C7\u08C3\x03\x02" + + "\x02\x02\u08C7\u08C5\x03\x02\x02\x02\u08C8\u08D4\x03\x02\x02\x02\u08C9" + + "\u08CA\f\x05\x02\x02\u08CA\u08CB\t\x15\x02\x02\u08CB\u08D3\x05\u0136\x9C" + + "\x06\u08CC\u08CD\f\x04\x02\x02\u08CD\u08CE\t\x14\x02\x02\u08CE\u08D3\x05" + + "\u0136\x9C\x05\u08CF\u08D0\f\x03\x02\x02\u08D0\u08D1\x07\xF3\x02\x02\u08D1" + + "\u08D3\x05\u0136\x9C\x04\u08D2\u08C9\x03\x02\x02\x02\u08D2\u08CC\x03\x02" + + "\x02\x02\u08D2\u08CF\x03\x02\x02\x02\u08D3\u08D6\x03\x02\x02\x02\u08D4" + + "\u08D2\x03\x02\x02\x02\u08D4\u08D5\x03\x02\x02\x02\u08D5\u0137\x03\x02" + + "\x02\x02\u08D6\u08D4\x03\x02\x02\x02\u08D7\u08D8\b\x9D\x01\x02\u08D8\u09CE" + + "\x07\x86\x02\x02\u08D9\u09CE\x05\u0142\xA2\x02\u08DA\u08DB\x05\u0164\xB3" + + "\x02\u08DB\u08DC\x05\u013A\x9E\x02\u08DC\u09CE\x03\x02\x02\x02\u08DD\u08DE" + + "\x07\u010D\x02\x02\u08DE\u09CE\x05\u013A\x9E\x02\u08DF\u09CE\x05\u0166" + + "\xB4\x02\u08E0\u09CE\x05\u0140\xA1\x02\u08E1\u09CE\x05\u013A\x9E\x02\u08E2" + + "\u09CE\x07\u0103\x02\x02\u08E3\u09CE\x07\xFF\x02\x02\u08E4\u08E5\x07\x95" + + "\x02\x02\u08E5\u08E6\x07\xF8\x02\x02\u08E6\u08E7\x05\u0136\x9C\x02\u08E7" + + "\u08E8\x07`\x02\x02\u08E8\u08E9\x05\u0136\x9C\x02\u08E9\u08EA\x07\xF9" + + "\x02\x02\u08EA\u09CE\x03\x02\x02\x02\u08EB\u08EC\x07\xF8\x02\x02\u08EC" + + "\u08EF\x05\u0130\x99\x02\u08ED\u08EE\x07\v\x02\x02\u08EE\u08F0\x05\u0148" + + "\xA5\x02\u08EF\u08ED\x03\x02\x02\x02\u08EF\u08F0\x03\x02\x02\x02\u08F0" + + "\u08F9\x03\x02\x02\x02\u08F1\u08F2\x07\xF6\x02\x02\u08F2\u08F5\x05\u0130" + + "\x99\x02\u08F3\u08F4\x07\v\x02\x02\u08F4\u08F6\x05\u0148\xA5\x02\u08F5" + + "\u08F3\x03\x02\x02\x02\u08F5\u08F6\x03\x02\x02\x02\u08F6\u08F8\x03\x02" + + "\x02\x02\u08F7\u08F1\x03\x02\x02\x02\u08F8\u08FB\x03\x02\x02\x02\u08F9" + + "\u08FA\x03\x02\x02\x02\u08F9\u08F7\x03\x02\x02\x02\u08FA\u08FC\x03\x02" + + "\x02\x02\u08FB\u08F9\x03\x02\x02\x02\u08FC\u08FD\x07\xF9\x02\x02\u08FD" + + "\u09CE\x03\x02\x02\x02\u08FE\u08FF\x07\xA9\x02\x02\u08FF\u0900\x07\xF8" + + "\x02\x02\u0900\u0905\x05\u0130\x99\x02\u0901\u0902\x07\xF6\x02\x02\u0902" + + "\u0904\x05\u0130\x99\x02\u0903\u0901\x03\x02\x02\x02\u0904\u0907\x03\x02" + + "\x02\x02\u0905\u0903\x03\x02\x02\x02\u0905\u0906\x03\x02\x02\x02\u0906" + + "\u0908\x03\x02\x02\x02\u0907\u0905\x03\x02\x02\x02\u0908\u0909\x07\xF9" + + "\x02\x02\u0909\u09CE\x03\x02\x02\x02\u090A\u090B\x05\xBE`\x02\u090B\u090C" + + "\x07\xF8\x02\x02\u090C\u090D\x07\xF0\x02\x02\u090D\u090F\x07\xF9\x02\x02" + + "\u090E\u0910\x05\u0150\xA9\x02\u090F\u090E\x03\x02\x02\x02\u090F\u0910" + + "\x03\x02\x02\x02\u0910\u0912\x03\x02\x02\x02\u0911\u0913\x05\u0152\xAA" + + "\x02\u0912\u0911\x03\x02\x02\x02\u0912\u0913\x03\x02\x02\x02\u0913\u09CE" + + "\x03\x02\x02\x02\u0914\u0915\x05\xBE`\x02\u0915\u0921\x07\xF8\x02\x02" + + "\u0916\u0918\x05\u0112\x8A\x02\u0917\u0916\x03\x02\x02\x02\u0917\u0918" + + "\x03\x02\x02\x02\u0918\u0919\x03\x02\x02\x02\u0919\u091E\x05\u0130\x99" + + "\x02\u091A\u091B\x07\xF6\x02\x02\u091B\u091D\x05\u0130\x99\x02\u091C\u091A" + + "\x03\x02\x02\x02\u091D\u0920\x03\x02\x02\x02\u091E\u091C\x03\x02\x02\x02" + + "\u091E\u091F\x03\x02\x02\x02\u091F\u0922\x03\x02\x02\x02\u0920\u091E\x03" + + "\x02\x02\x02\u0921\u0917\x03\x02\x02\x02\u0921\u0922\x03\x02\x02\x02\u0922" + + "\u092D\x03\x02\x02\x02\u0923\u0924\x07\x8C\x02\x02\u0924\u0925\x07\x1C" + + "\x02\x02\u0925\u092A\x05\u0106\x84\x02\u0926\u0927\x07\xF6\x02\x02\u0927" + + "\u0929\x05\u0106\x84\x02\u0928\u0926\x03\x02\x02\x02\u0929\u092C\x03\x02" + + "\x02\x02\u092A\u0928\x03\x02\x02\x02\u092A\u092B\x03\x02\x02\x02\u092B" + + "\u092E\x03\x02\x02\x02\u092C\u092A\x03\x02\x02\x02\u092D\u0923\x03\x02" + + "\x02\x02\u092D\u092E\x03\x02\x02\x02\u092E\u092F\x03\x02\x02\x02\u092F" + + "\u0931\x07\xF9\x02\x02\u0930\u0932\x05\u0150\xA9\x02\u0931\u0930\x03\x02" + + "\x02\x02\u0931\u0932\x03\x02\x02\x02\u0932\u0934\x03\x02\x02\x02\u0933" + + "\u0935\x05\u0152\xAA\x02\u0934\u0933\x03\x02\x02\x02\u0934\u0935\x03\x02" + + "\x02\x02\u0935\u09CE\x03\x02\x02\x02\u0936\u0937\x05\u0164\xB3\x02\u0937" + + "\u0938\x07\u0100\x02\x02\u0938\u0939\x05\u0130\x99\x02\u0939\u09CE\x03" + + "\x02\x02\x02\u093A\u0943\x07\xF8\x02\x02\u093B\u0940\x05\u0164\xB3\x02" + + "\u093C\u093D\x07\xF6\x02\x02\u093D\u093F\x05\u0164\xB3\x02\u093E\u093C" + + "\x03\x02\x02\x02\u093F\u0942\x03\x02\x02\x02\u0940\u093E\x03\x02\x02\x02" + + "\u0940\u0941\x03\x02\x02\x02\u0941\u0944\x03\x02\x02\x02\u0942\u0940\x03" + + "\x02\x02\x02\u0943\u093B\x03\x02\x02\x02\u0943\u0944\x03\x02\x02\x02\u0944" + + "\u0945\x03\x02\x02\x02\u0945\u0946\x07\xF9\x02\x02\u0946\u0947\x07\u0100" + + "\x02\x02\u0947\u09CE\x05\u0130\x99\x02\u0948\u0949\x07\xF8\x02\x02\u0949" + + "\u094A\x05\xCCg\x02\u094A\u094B\x07\xF9\x02\x02\u094B\u09CE\x03\x02\x02" + + "\x02\u094C\u094D\x07D\x02\x02\u094D\u094E\x07\xF8\x02\x02\u094E\u094F" + + "\x05\xCCg\x02\u094F\u0950\x07\xF9\x02\x02\u0950\u09CE\x03\x02\x02\x02" + + "\u0951\u0952\x07\x1E\x02\x02\u0952\u0954\x05\u0136\x9C\x02\u0953\u0955" + + "\x05\u014E\xA8\x02\u0954\u0953\x03\x02\x02\x02\u0955\u0956\x03\x02\x02" + + "\x02\u0956\u0954\x03\x02\x02\x02\u0956\u0957\x03\x02\x02\x02\u0957\u095A" + + "\x03\x02\x02\x02\u0958\u0959\x07=\x02\x02\u0959\u095B\x05\u0130\x99\x02" + + "\u095A\u0958\x03\x02\x02\x02\u095A\u095B\x03\x02\x02\x02\u095B\u095C\x03" + + "\x02\x02\x02\u095C\u095D\x07?\x02\x02\u095D\u09CE\x03\x02\x02\x02\u095E" + + "\u0960\x07\x1E\x02\x02\u095F\u0961\x05\u014E\xA8\x02\u0960\u095F\x03\x02" + + "\x02\x02\u0961\u0962\x03\x02\x02\x02\u0962\u0960\x03\x02\x02\x02\u0962" + + "\u0963\x03\x02\x02\x02\u0963\u0966\x03\x02\x02\x02\u0964\u0965\x07=\x02" + + "\x02\u0965\u0967\x05\u0130\x99\x02\u0966\u0964\x03\x02\x02\x02\u0966\u0967" + + "\x03\x02\x02\x02\u0967\u0968\x03\x02\x02\x02\u0968\u0969\x07?\x02\x02" + + "\u0969\u09CE\x03\x02\x02\x02\u096A\u096B\x07\x1F\x02\x02\u096B\u096C\x07" + + "\xF8\x02\x02\u096C\u096D\x05\u0130\x99\x02\u096D\u096E\x07\v\x02\x02\u096E" + + "\u096F\x05\u0148\xA5\x02\u096F\u0970\x07\xF9\x02\x02\u0970\u09CE\x03\x02" + + "\x02\x02\u0971\u0972\x07\xC5\x02\x02\u0972\u0973\x07\xF8\x02\x02\u0973" + + "\u0974\x05\u0130\x99\x02\u0974\u0975\x07\v\x02\x02\u0975\u0976\x05\u0148" + + "\xA5\x02\u0976\u0977\x07\xF9\x02\x02\u0977\u09CE\x03\x02\x02\x02\u0978" + + "\u0979\x07\n\x02\x02\u0979\u0982\x07\xFA\x02\x02\u097A\u097F\x05\u0130" + + "\x99\x02\u097B\u097C\x07\xF6\x02\x02\u097C\u097E\x05\u0130\x99\x02\u097D" + + "\u097B\x03\x02\x02\x02\u097E\u0981\x03\x02\x02\x02\u097F\u097D\x03\x02" + + "\x02\x02\u097F\u0980\x03\x02\x02\x02\u0980\u0983\x03\x02\x02\x02\u0981" + + "\u097F\x03\x02\x02\x02\u0982\u097A\x03\x02\x02\x02\u0982\u0983\x03\x02" + + "\x02\x02\u0983\u0984\x03\x02\x02\x02\u0984\u09CE\x07\xFB\x02\x02\u0985" + + "\u09CE\x05\u0164\xB3\x02\u0986\u09CE\x07*\x02\x02\u0987\u098B\x07,\x02" + + "\x02\u0988\u0989\x07\xF8\x02\x02\u0989\u098A\x07\u0104\x02\x02\u098A\u098C" + + "\x07\xF9\x02\x02\u098B\u0988\x03\x02\x02\x02\u098B\u098C\x03\x02\x02\x02" + + "\u098C\u09CE\x03\x02\x02\x02\u098D\u0991\x07-\x02\x02\u098E\u098F\x07" + + "\xF8\x02\x02\u098F\u0990\x07\u0104\x02\x02\u0990\u0992\x07\xF9\x02\x02" + + "\u0991\u098E\x03\x02\x02\x02\u0991\u0992\x03\x02\x02\x02\u0992\u09CE\x03" + + "\x02\x02\x02\u0993\u0997\x07w\x02\x02\u0994\u0995\x07\xF8\x02\x02\u0995" + + "\u0996\x07\u0104\x02\x02\u0996\u0998\x07\xF9\x02\x02\u0997\u0994\x03\x02" + + "\x02\x02\u0997\u0998\x03\x02\x02\x02\u0998\u09CE\x03\x02\x02\x02\u0999" + + "\u099D\x07x\x02\x02\u099A\u099B\x07\xF8\x02\x02\u099B\u099C\x07\u0104" + + "\x02\x02\u099C\u099E\x07\xF9\x02\x02\u099D\u099A\x03\x02\x02\x02\u099D" + + "\u099E\x03\x02\x02\x02\u099E\u09CE\x03\x02\x02\x02\u099F\u09CE\x07.\x02" + + "\x02\u09A0\u09CE\x07+\x02\x02\u09A1\u09A2\x07\xBA\x02\x02\u09A2\u09A3" + + "\x07\xF8\x02\x02\u09A3\u09A4\x05\u0136\x9C\x02\u09A4\u09A5\x07T\x02\x02" + + "\u09A5\u09A8\x05\u0136\x9C\x02\u09A6\u09A7\x07P\x02\x02\u09A7\u09A9\x05" + + "\u0136\x9C\x02\u09A8\u09A6\x03\x02\x02\x02\u09A8\u09A9\x03\x02\x02\x02" + + "\u09A9\u09AA\x03\x02\x02\x02\u09AA\u09AB\x07\xF9\x02\x02\u09AB\u09CE\x03" + + "\x02\x02\x02\u09AC\u09AD\x07\x84\x02\x02\u09AD\u09AE\x07\xF8\x02\x02\u09AE" + + "\u09B1\x05\u0136\x9C\x02\u09AF\u09B0\x07\xF6\x02\x02\u09B0\u09B2\x05\u0146" + + "\xA4\x02\u09B1\u09AF\x03\x02\x02\x02\u09B1\u09B2\x03\x02\x02\x02\u09B2" + + "\u09B3\x03\x02\x02\x02\u09B3\u09B4\x07\xF9\x02\x02\u09B4\u09CE\x03\x02" + + "\x02\x02\u09B5\u09B6\x07F\x02\x02\u09B6\u09B7\x07\xF8\x02\x02\u09B7\u09B8" + + "\x05\u0164\xB3\x02\u09B8\u09B9\x07T\x02\x02\u09B9\u09BA\x05\u0136\x9C" + + "\x02\u09BA\u09BB\x07\xF9\x02\x02\u09BB\u09CE\x03\x02\x02\x02\u09BC\u09BD" + + "\x07\xF8\x02\x02\u09BD\u09BE\x05\u0130\x99\x02\u09BE\u09BF\x07\xF9\x02" + + "\x02\u09BF\u09CE\x03\x02\x02\x02\u09C0\u09C1\x07Z\x02\x02\u09C1\u09CA" + + "\x07\xF8\x02\x02\u09C2\u09C7\x05\u0160\xB1\x02\u09C3\u09C4\x07\xF6\x02" + + "\x02\u09C4\u09C6\x05\u0160\xB1\x02\u09C5\u09C3\x03\x02\x02\x02\u09C6\u09C9" + + "\x03\x02\x02\x02\u09C7\u09C5\x03\x02\x02\x02\u09C7\u09C8\x03\x02\x02\x02" + + "\u09C8\u09CB\x03\x02\x02\x02\u09C9\u09C7\x03\x02\x02\x02\u09CA\u09C2\x03" + + "\x02\x02\x02\u09CA\u09CB\x03\x02\x02\x02\u09CB\u09CC\x03\x02\x02\x02\u09CC" + + "\u09CE\x07\xF9\x02\x02\u09CD\u08D7\x03\x02\x02\x02\u09CD\u08D9\x03\x02" + + "\x02\x02\u09CD\u08DA\x03\x02\x02\x02\u09CD\u08DD\x03\x02\x02\x02\u09CD" + + "\u08DF\x03\x02\x02\x02\u09CD\u08E0\x03\x02\x02\x02\u09CD\u08E1\x03\x02" + + "\x02\x02\u09CD\u08E2\x03\x02\x02\x02\u09CD\u08E3\x03\x02\x02\x02\u09CD" + + "\u08E4\x03\x02\x02\x02\u09CD\u08EB\x03\x02\x02\x02\u09CD\u08FE\x03\x02" + + "\x02\x02\u09CD\u090A\x03\x02\x02\x02\u09CD\u0914\x03\x02\x02\x02\u09CD" + + "\u0936\x03\x02\x02\x02\u09CD\u093A\x03\x02\x02\x02\u09CD\u0948\x03\x02" + + "\x02\x02\u09CD\u094C\x03\x02\x02\x02\u09CD\u0951\x03\x02\x02\x02\u09CD" + + "\u095E\x03\x02\x02\x02\u09CD\u096A\x03\x02\x02\x02\u09CD\u0971\x03\x02" + + "\x02\x02\u09CD\u0978\x03\x02\x02\x02\u09CD\u0985\x03\x02\x02\x02\u09CD" + + "\u0986\x03\x02\x02\x02\u09CD\u0987\x03\x02\x02\x02\u09CD\u098D\x03\x02" + + "\x02\x02\u09CD\u0993\x03\x02\x02\x02\u09CD\u0999\x03\x02\x02\x02\u09CD" + + "\u099F\x03\x02\x02\x02\u09CD\u09A0\x03\x02\x02\x02\u09CD\u09A1\x03\x02" + + "\x02\x02\u09CD\u09AC\x03\x02\x02\x02\u09CD\u09B5\x03\x02\x02\x02\u09CD" + + "\u09BC\x03\x02\x02\x02\u09CD\u09C0\x03\x02\x02\x02\u09CE\u09D9\x03\x02" + + "\x02\x02\u09CF\u09D0\f\x11\x02\x02\u09D0\u09D1\x07\xFA\x02\x02\u09D1\u09D2" + + "\x05\u0136\x9C\x02\u09D2\u09D3\x07\xFB\x02\x02\u09D3\u09D8\x03\x02\x02" + + "\x02\u09D4\u09D5\f\x0F\x02\x02\u09D5\u09D6\x07\xF4\x02\x02\u09D6\u09D8" + + "\x05\u0164\xB3\x02\u09D7\u09CF\x03\x02\x02\x02\u09D7\u09D4\x03\x02\x02" + + "\x02\u09D8\u09DB\x03\x02\x02\x02\u09D9\u09D7\x03\x02\x02\x02\u09D9\u09DA" + + "\x03\x02\x02\x02\u09DA\u0139\x03\x02\x02\x02\u09DB\u09D9\x03\x02\x02\x02" + + "\u09DC\u09E3\x07\u0101\x02\x02\u09DD\u09E0\x07\u0102\x02\x02\u09DE\u09DF" + + "\x07\xC8\x02\x02\u09DF\u09E1\x07\u0101\x02\x02\u09E0\u09DE\x03\x02\x02" + + "\x02\u09E0\u09E1\x03\x02\x02\x02\u09E1\u09E3\x03\x02\x02\x02\u09E2\u09DC" + + "\x03\x02\x02\x02\u09E2\u09DD\x03\x02\x02\x02\u09E3\u013B\x03\x02\x02\x02" + + "\u09E4\u09E5\t\x16\x02\x02\u09E5\u013D\x03\x02\x02\x02\u09E6\u09E7\t\x17" + + "\x02\x02\u09E7\u013F\x03\x02\x02\x02\u09E8\u09E9\t\x18\x02\x02\u09E9\u0141" + + "\x03\x02\x02\x02\u09EA\u09EB\x07\u0104\x02\x02\u09EB\u09F9\x05\u0144\xA3" + + "\x02\u09EC\u09ED\x07\xF8\x02\x02\u09ED\u09EE\x07\u0104\x02\x02\u09EE\u09EF" + + "\x07\xF9\x02\x02\u09EF\u09F9\x05\u0144\xA3\x02\u09F0\u09F1\x07g\x02\x02" + + "\u09F1\u09F2\x07\u0104\x02\x02\u09F2\u09F9\x05\u0144\xA3\x02\u09F3\u09F4" + + "\x07g\x02\x02\u09F4\u09F5\x07\xF8\x02\x02\u09F5\u09F6\x07\u0104\x02\x02" + + "\u09F6\u09F7\x07\xF9\x02\x02\u09F7\u09F9\x05\u0144\xA3\x02\u09F8\u09EA" + + "\x03\x02\x02\x02\u09F8\u09EC\x03\x02\x02\x02\u09F8\u09F0\x03\x02\x02\x02" + + "\u09F8\u09F3\x03\x02\x02\x02\u09F9\u0143\x03\x02\x02\x02\u09FA\u09FB\t" + + "\x19\x02\x02\u09FB\u0145\x03\x02\x02\x02\u09FC\u09FD\t\x1A\x02\x02\u09FD" + + "\u0147\x03\x02\x02\x02\u09FE\u09FF\b\xA5\x01\x02\u09FF\u0A00\x07\n\x02" + + "\x02\u0A00\u0A01\x07\xEA\x02\x02\u0A01\u0A02\x05\u0148\xA5\x02\u0A02\u0A03" + + "\x07\xEC\x02\x02\u0A03\u0A2B\x03\x02\x02\x02\u0A04\u0A05\x07z\x02\x02" + + "\u0A05\u0A06\x07\xEA\x02\x02\u0A06\u0A07\x05\u0148\xA5\x02\u0A07\u0A08" + + "\x07\xF6\x02\x02\u0A08\u0A09\x05\u0148\xA5\x02\u0A09\u0A0A\x07\xEC\x02" + + "\x02\u0A0A\u0A2B\x03\x02\x02\x02\u0A0B\u0A0C\x07\xB8\x02\x02\u0A0C\u0A0D" + + "\x07\xEA\x02\x02\u0A0D\u0A0E\x05\u0164\xB3\x02\u0A0E\u0A0F\x07\xF7\x02" + + "\x02\u0A0F\u0A17\x05\u0148\xA5\x02\u0A10\u0A11\x07\xF6\x02\x02\u0A11\u0A12" + + "\x05\u0164\xB3\x02\u0A12\u0A13\x07\xF7\x02\x02\u0A13\u0A14\x05\u0148\xA5" + + "\x02\u0A14\u0A16\x03\x02\x02\x02\u0A15\u0A10\x03\x02\x02\x02\u0A16\u0A19" + + "\x03\x02\x02\x02\u0A17\u0A15\x03\x02\x02\x02\u0A17\u0A18\x03\x02\x02\x02" + + "\u0A18\u0A1A\x03\x02\x02\x02\u0A19\u0A17\x03\x02\x02\x02\u0A1A\u0A1B\x07" + + "\xEC\x02\x02\u0A1B\u0A2B\x03\x02\x02\x02\u0A1C\u0A28\x05\u014C\xA7\x02" + + "\u0A1D\u0A1E\x07\xF8\x02\x02\u0A1E\u0A23\x05\u014A\xA6\x02\u0A1F\u0A20" + + "\x07\xF6\x02\x02\u0A20\u0A22\x05\u014A\xA6\x02\u0A21\u0A1F\x03\x02\x02" + + "\x02\u0A22\u0A25\x03\x02\x02\x02\u0A23\u0A21\x03\x02\x02\x02\u0A23\u0A24" + + "\x03\x02\x02\x02\u0A24\u0A26\x03\x02\x02\x02\u0A25\u0A23\x03\x02\x02\x02" + + "\u0A26\u0A27\x07\xF9\x02\x02\u0A27\u0A29\x03\x02\x02\x02\u0A28\u0A1D\x03" + + "\x02\x02\x02\u0A28\u0A29\x03\x02\x02\x02\u0A29\u0A2B\x03\x02\x02\x02\u0A2A" + + "\u09FE\x03\x02\x02\x02\u0A2A\u0A04\x03\x02\x02\x02\u0A2A\u0A0B\x03\x02" + + "\x02\x02\u0A2A\u0A1C\x03\x02\x02\x02\u0A2B\u0A30\x03\x02\x02\x02\u0A2C" + + "\u0A2D\f\x07\x02\x02\u0A2D\u0A2F\x07\n\x02\x02\u0A2E\u0A2C\x03\x02\x02" + + "\x02\u0A2F\u0A32\x03\x02\x02\x02\u0A30\u0A2E\x03\x02\x02\x02\u0A30\u0A31" + + "\x03\x02\x02\x02\u0A31\u0149\x03\x02\x02\x02\u0A32\u0A30\x03\x02\x02\x02" + + "\u0A33\u0A36\x07\u0104\x02\x02\u0A34\u0A36\x05\u0148\xA5\x02\u0A35\u0A33" + + "\x03\x02\x02\x02\u0A35\u0A34\x03\x02\x02\x02\u0A36\u014B\x03\x02\x02\x02" + + "\u0A37\u0A3C\x07\u010B\x02\x02\u0A38\u0A3C\x07\u010C\x02\x02\u0A39\u0A3C" + + "\x07\u010D\x02\x02\u0A3A\u0A3C\x05\u0164\xB3\x02\u0A3B\u0A37\x03\x02\x02" + + "\x02\u0A3B\u0A38\x03\x02\x02\x02\u0A3B\u0A39\x03\x02\x02\x02\u0A3B\u0A3A" + + "\x03\x02\x02\x02\u0A3C\u014D\x03\x02\x02\x02\u0A3D\u0A3E\x07\xD7\x02\x02" + + "\u0A3E\u0A3F\x05\u0130\x99\x02\u0A3F\u0A40\x07\xC2\x02\x02\u0A40\u0A41" + + "\x05\u0130\x99\x02\u0A41\u014F\x03\x02\x02\x02\u0A42\u0A43\x07L\x02\x02" + + "\u0A43\u0A44\x07\xF8\x02\x02\u0A44\u0A45\x07\xD8\x02\x02\u0A45\u0A46\x05" + + "\u0132\x9A\x02\u0A46\u0A47\x07\xF9\x02\x02\u0A47\u0151\x03\x02\x02\x02" + + "\u0A48\u0A49\x07\x90\x02\x02\u0A49\u0A54\x07\xF8\x02\x02\u0A4A\u0A4B\x07" + + "\x92\x02\x02\u0A4B\u0A4C\x07\x1C\x02\x02\u0A4C\u0A51\x05\u0130\x99\x02" + + "\u0A4D\u0A4E\x07\xF6\x02\x02\u0A4E\u0A50\x05\u0130\x99\x02\u0A4F\u0A4D" + + "\x03\x02\x02\x02\u0A50\u0A53\x03\x02\x02\x02\u0A51\u0A4F\x03\x02\x02\x02" + + "\u0A51\u0A52\x03\x02\x02\x02\u0A52\u0A55\x03\x02\x02\x02\u0A53\u0A51\x03" + + "\x02\x02\x02\u0A54\u0A4A\x03\x02\x02\x02\u0A54\u0A55\x03\x02\x02\x02\u0A55" + + "\u0A60\x03\x02\x02\x02\u0A56\u0A57\x07\x8C\x02\x02\u0A57\u0A58\x07\x1C" + + "\x02\x02\u0A58\u0A5D\x05\u0106\x84\x02\u0A59\u0A5A\x07\xF6\x02\x02\u0A5A" + + "\u0A5C\x05\u0106\x84\x02\u0A5B\u0A59\x03\x02\x02\x02\u0A5C\u0A5F\x03\x02" + + "\x02\x02\u0A5D\u0A5B\x03\x02\x02\x02\u0A5D\u0A5E\x03\x02\x02\x02\u0A5E" + + "\u0A61\x03\x02\x02\x02\u0A5F\u0A5D\x03\x02\x02\x02\u0A60\u0A56\x03\x02" + + "\x02\x02\u0A60\u0A61\x03\x02\x02\x02\u0A61\u0A63\x03\x02\x02\x02\u0A62" + + "\u0A64\x05\u0154\xAB\x02\u0A63\u0A62\x03\x02\x02\x02\u0A63\u0A64\x03\x02" + + "\x02\x02\u0A64\u0A65\x03\x02\x02\x02\u0A65\u0A66\x07\xF9\x02\x02\u0A66" + + "\u0153\x03\x02\x02\x02\u0A67\u0A68\x07\x9B\x02\x02\u0A68\u0A78\x05\u0156" + + "\xAC\x02\u0A69\u0A6A\x07\xAA\x02\x02\u0A6A\u0A78\x05\u0156\xAC\x02\u0A6B" + + "\u0A6C\x07\x9B\x02\x02\u0A6C\u0A6D\x07\x11\x02\x02\u0A6D\u0A6E\x05\u0156" + + "\xAC\x02\u0A6E\u0A6F\x07\x07\x02\x02\u0A6F\u0A70\x05\u0156\xAC\x02\u0A70" + + "\u0A78\x03\x02\x02\x02\u0A71\u0A72\x07\xAA\x02\x02\u0A72\u0A73\x07\x11" + + "\x02\x02\u0A73\u0A74\x05\u0156\xAC\x02\u0A74\u0A75\x07\x07\x02\x02\u0A75" + + "\u0A76\x05\u0156\xAC\x02\u0A76\u0A78\x03\x02\x02\x02\u0A77\u0A67\x03\x02" + + "\x02\x02\u0A77\u0A69\x03\x02\x02\x02\u0A77\u0A6B\x03\x02\x02\x02\u0A77" + + "\u0A71\x03\x02\x02\x02\u0A78\u0155\x03\x02\x02\x02\u0A79\u0A7A\x07\xC9" + + "\x02\x02\u0A7A\u0A83\x07\x96\x02\x02\u0A7B\u0A7C\x07\xC9\x02\x02\u0A7C" + + "\u0A83\x07O\x02\x02\u0A7D\u0A7E\x07)\x02\x02\u0A7E\u0A83\x07\xA9\x02\x02" + + "\u0A7F\u0A80\x05\u0130\x99\x02\u0A80\u0A81\t\x1B\x02\x02\u0A81\u0A83\x03" + + "\x02\x02\x02\u0A82\u0A79\x03\x02\x02\x02\u0A82\u0A7B\x03\x02\x02\x02\u0A82" + + "\u0A7D\x03\x02\x02\x02\u0A82\u0A7F\x03\x02\x02\x02\u0A83\u0157\x03\x02" + + "\x02\x02\u0A84\u0A85\x05\u0164\xB3\x02\u0A85\u0A86\x07\xF4\x02\x02\u0A86" + + "\u0A87\x05\u0164\xB3\x02\u0A87\u0A8A\x03\x02\x02\x02\u0A88\u0A8A\x05\u0164" + + "\xB3\x02\u0A89\u0A84\x03\x02\x02\x02\u0A89\u0A88\x03\x02\x02\x02\u0A8A" + + "\u0159\x03\x02\x02\x02\u0A8B\u0A90\x05\u0158\xAD\x02\u0A8C\u0A8D\x07\xF6" + + "\x02\x02\u0A8D\u0A8F\x05\u0158\xAD\x02\u0A8E\u0A8C\x03\x02\x02\x02\u0A8F" + + "\u0A92\x03\x02\x02\x02\u0A90\u0A8E\x03\x02\x02\x02\u0A90\u0A91\x03\x02" + + "\x02\x02\u0A91\u015B\x03\x02\x02\x02\u0A92\u0A90\x03\x02\x02\x02\u0A93" + + "\u0AA1\x07\x04\x02\x02\u0A94\u0AA1\x07\x06\x02\x02\u0A95\u0AA1\x07<\x02" + + "\x02\u0A96\u0AA1\x07\'\x02\x02\u0A97\u0AA1\x07e\x02\x02\u0A98\u0AA1\x07" + + "\xA3\x02\x02\u0A99\u0A9E\x07\xAF\x02\x02\u0A9A\u0A9B\x07\xF8\x02\x02\u0A9B" + + "\u0A9C\x05\u0164\xB3\x02\u0A9C\u0A9D\x07\xF9\x02\x02\u0A9D\u0A9F\x03\x02" + + "\x02\x02\u0A9E\u0A9A\x03\x02\x02\x02\u0A9E\u0A9F\x03\x02\x02\x02\u0A9F" + + "\u0AA1\x03\x02\x02\x02\u0AA0\u0A93\x03\x02\x02\x02\u0AA0\u0A94\x03\x02" + + "\x02\x02\u0AA0\u0A95\x03\x02\x02\x02\u0AA0\u0A96\x03\x02\x02\x02\u0AA0" + + "\u0A97\x03\x02\x02\x02\u0AA0\u0A98\x03\x02\x02\x02\u0AA0\u0A99\x03\x02" + + "\x02\x02\u0AA1\u015D\x03\x02\x02\x02\u0AA2\u0AA3\t\x1C\x02\x02\u0AA3\u015F" + + "\x03\x02\x02\x02\u0AA4\u0AA9\x05\u0164\xB3\x02\u0AA5\u0AA6\x07\xF4\x02" + + "\x02\u0AA6\u0AA8\x05\u0164\xB3\x02\u0AA7\u0AA5\x03\x02\x02\x02\u0AA8\u0AAB" + + "\x03\x02\x02\x02\u0AA9\u0AA7\x03\x02\x02\x02\u0AA9\u0AAA\x03\x02\x02\x02" + + "\u0AAA\u0161\x03\x02\x02\x02\u0AAB\u0AA9\x03\x02\x02\x02\u0AAC\u0AAD\x07" + + "\xA7\x02\x02\u0AAD\u0AB3\x05\u0164\xB3\x02\u0AAE\u0AAF\x07\xCE\x02\x02" + + "\u0AAF\u0AB3\x05\u0164\xB3\x02\u0AB0\u0AB1\x07Y\x02\x02\u0AB1\u0AB3\x05" + + "\u0164\xB3\x02\u0AB2\u0AAC\x03\x02\x02\x02\u0AB2\u0AAE\x03\x02\x02\x02" + + "\u0AB2\u0AB0\x03\x02\x02\x02\u0AB3\u0163\x03\x02\x02\x02\u0AB4\u0ABA\x07" + + "\u0107\x02\x02\u0AB5\u0ABA\x07\u0101\x02\x02\u0AB6\u0ABA\x05\u0168\xB5" + + "\x02\u0AB7\u0ABA\x07\u010A\x02\x02\u0AB8\u0ABA\x07\u0108\x02\x02\u0AB9" + + "\u0AB4\x03\x02\x02\x02\u0AB9\u0AB5\x03\x02\x02\x02\u0AB9\u0AB6\x03\x02" + + "\x02\x02\u0AB9\u0AB7\x03\x02\x02\x02\u0AB9\u0AB8\x03\x02\x02\x02\u0ABA" + + "\u0165\x03\x02\x02\x02\u0ABB\u0ABD\x07\xEF\x02\x02\u0ABC\u0ABB\x03\x02" + + "\x02\x02\u0ABC\u0ABD\x03\x02\x02\x02\u0ABD\u0ABE\x03\x02\x02\x02\u0ABE" + + "\u0AC8\x07\u0105"; + private static readonly _serializedATNSegment5: string = + "\x02\x02\u0ABF\u0AC1\x07\xEF\x02\x02\u0AC0\u0ABF\x03\x02\x02\x02\u0AC0" + + "\u0AC1\x03\x02\x02\x02\u0AC1\u0AC2\x03\x02\x02\x02\u0AC2\u0AC8\x07\u0106" + + "\x02\x02\u0AC3\u0AC5\x07\xEF\x02\x02\u0AC4\u0AC3\x03\x02\x02\x02\u0AC4" + + "\u0AC5\x03\x02\x02\x02\u0AC5\u0AC6\x03\x02\x02\x02\u0AC6\u0AC8\x07\u0104" + + "\x02\x02\u0AC7\u0ABC\x03\x02\x02\x02\u0AC7\u0AC0\x03\x02\x02\x02\u0AC7" + + "\u0AC4\x03\x02\x02\x02\u0AC8\u0167\x03\x02\x02\x02\u0AC9\u0ACA\t\x1D\x02" + + "\x02\u0ACA\u0169\x03\x02\x02\x02\u0160\u016C\u0170\u018B\u0198\u019C\u01A0" + + "\u01A9\u01AE\u01B2\u01B8\u01BA\u01BF\u01C3\u01C7\u01CE\u01D3\u01D9\u01DD" + + "\u01E6\u01ED\u01F1\u01F6\u01F8\u01FD\u0201\u0208\u020C\u0211\u0215\u0219" + + "\u021D\u0225\u022A\u022E\u0236\u023A\u0243\u0246\u0249\u024F\u0256\u0261" + + "\u0266\u026B\u0270\u0275\u027E\u0281\u0284\u0288\u02A2\u02BC\u02C5\u02CF" + + "\u02D2\u02E0\u02F2\u02F4\u02FD\u0308\u0311\u0318\u031C\u0323\u0329\u032C" + + "\u0331\u0338\u0346\u0353\u0358\u035D\u0363\u0387\u038A\u0390\u0393\u0399" + + "\u039F\u03AB\u03AD\u03B5\u03BD\u03C2\u03C6\u03CB\u03D2\u03D6\u03DA\u03E0" + + "\u03E4\u03E8\u03F1\u03F4\u03F7\u03FF\u040D\u0414\u0421\u0427\u042C\u042F" + + "\u0432\u0437\u043B\u0444\u0449\u044F\u0453\u0458\u045D\u0460\u0468\u046B" + + "\u046F\u047B\u047E\u0482\u0487\u048B\u049B\u04A0\u04A7\u04AA\u04B0\u04B3" + + "\u04BA\u04BD\u04C1\u04C6\u04C9\u04D0\u04D3\u04EB\u04F9\u04FD\u0501\u0515" + + "\u0517\u0519\u0522\u0524\u052D\u052F\u0538\u053A\u053F\u0548\u0551\u055A" + + "\u0565\u056B\u0570\u0573\u0580\u058A\u058E\u0593\u059E\u05A3\u05C4\u05CC" + + "\u05D5\u05DA\u05DE\u05E3\u05E8\u05ED\u05F1\u05FA\u05FD\u0601\u0608\u0613" + + "\u0619\u061D\u0623\u062D\u0634\u0639\u063E\u0643\u0649\u064C\u0655\u0658" + + "\u065B\u0661\u066B\u066E\u0672\u0676\u067C\u0682\u0685\u068B\u0691\u0694" + + "\u0697\u069B\u06A5\u06B0\u06B5\u06B8\u06BC\u06C3\u06CD\u06D9\u06DF\u06E1" + + "\u06EA\u06ED\u06F4\u06FE\u0704\u070C\u0717\u0721\u072C\u072E\u0734\u0739" + + "\u0743\u0746\u074C\u074E\u0756\u075C\u075F\u0761\u076D\u0774\u0778\u077C" + + "\u0780\u0783\u078A\u0793\u0796\u079A\u079F\u07A3\u07A6\u07AD\u07B8\u07BB" + + "\u07BF\u07C3\u07CC\u07CF\u07D6\u07E4\u07E8\u07EC\u07F0\u07F4\u07F8\u07FC" + + "\u0800\u080A\u0815\u081A\u0827\u0829\u082F\u0833\u0835\u083D\u0848\u084F" + + "\u0854\u0861\u0867\u086F\u0876\u087A\u0882\u0884\u088F\u0897\u08A0\u08A6" + + "\u08AB\u08B1\u08B7\u08BC\u08C1\u08C7\u08D2\u08D4\u08EF\u08F5\u08F9\u0905" + + "\u090F\u0912\u0917\u091E\u0921\u092A\u092D\u0931\u0934\u0940\u0943\u0956" + + "\u095A\u0962\u0966\u097F\u0982\u098B\u0991\u0997\u099D\u09A8\u09B1\u09C7" + + "\u09CA\u09CD\u09D7\u09D9\u09E0\u09E2\u09F8\u0A17\u0A23\u0A28\u0A2A\u0A30" + + "\u0A35\u0A3B\u0A51\u0A54\u0A5D\u0A60\u0A63\u0A77\u0A82\u0A89\u0A90\u0A9E" + + "\u0AA0\u0AA9\u0AB2\u0AB9\u0ABC\u0AC0\u0AC4\u0AC7"; + public static readonly _serializedATN: string = Utils.join( + [ + ImpalaSqlParser._serializedATNSegment0, + ImpalaSqlParser._serializedATNSegment1, + ImpalaSqlParser._serializedATNSegment2, + ImpalaSqlParser._serializedATNSegment3, + ImpalaSqlParser._serializedATNSegment4, + ImpalaSqlParser._serializedATNSegment5, + ], + "", + ); + public static __ATN: ATN; + public static get _ATN(): ATN { + if (!ImpalaSqlParser.__ATN) { + ImpalaSqlParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(ImpalaSqlParser._serializedATN)); + } + + return ImpalaSqlParser.__ATN; + } + +} + +export class ProgramContext extends ParserRuleContext { + public EOF(): TerminalNode { return this.getToken(ImpalaSqlParser.EOF, 0); } + public statement(): StatementContext[]; + public statement(i: number): StatementContext; + public statement(i?: number): StatementContext | StatementContext[] { + if (i === undefined) { + return this.getRuleContexts(StatementContext); + } else { + return this.getRuleContext(i, StatementContext); + } + } + public SEMICOLON(): TerminalNode[]; + public SEMICOLON(i: number): TerminalNode; + public SEMICOLON(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.SEMICOLON); + } else { + return this.getToken(ImpalaSqlParser.SEMICOLON, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_program; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterProgram) { + listener.enterProgram(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitProgram) { + listener.exitProgram(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitProgram) { + return visitor.visitProgram(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class StatementContext extends ParserRuleContext { + public queryStatement(): QueryStatementContext | undefined { + return this.tryGetRuleContext(0, QueryStatementContext); + } + public useStatement(): UseStatementContext | undefined { + return this.tryGetRuleContext(0, UseStatementContext); + } + public createStatement(): CreateStatementContext | undefined { + return this.tryGetRuleContext(0, CreateStatementContext); + } + public alterStatement(): AlterStatementContext | undefined { + return this.tryGetRuleContext(0, AlterStatementContext); + } + public truncateTableStatement(): TruncateTableStatementContext | undefined { + return this.tryGetRuleContext(0, TruncateTableStatementContext); + } + public describeStatement(): DescribeStatementContext | undefined { + return this.tryGetRuleContext(0, DescribeStatementContext); + } + public computeStatement(): ComputeStatementContext | undefined { + return this.tryGetRuleContext(0, ComputeStatementContext); + } + public dropStatement(): DropStatementContext | undefined { + return this.tryGetRuleContext(0, DropStatementContext); + } + public grantStatement(): GrantStatementContext | undefined { + return this.tryGetRuleContext(0, GrantStatementContext); + } + public revokeStatement(): RevokeStatementContext | undefined { + return this.tryGetRuleContext(0, RevokeStatementContext); + } + public insertStatement(): InsertStatementContext | undefined { + return this.tryGetRuleContext(0, InsertStatementContext); + } + public deleteStatement(): DeleteStatementContext | undefined { + return this.tryGetRuleContext(0, DeleteStatementContext); + } + public updateStatement(): UpdateStatementContext | undefined { + return this.tryGetRuleContext(0, UpdateStatementContext); + } + public upsertStatement(): UpsertStatementContext | undefined { + return this.tryGetRuleContext(0, UpsertStatementContext); + } + public showStatement(): ShowStatementContext | undefined { + return this.tryGetRuleContext(0, ShowStatementContext); + } + public addCommentStatement(): AddCommentStatementContext | undefined { + return this.tryGetRuleContext(0, AddCommentStatementContext); + } + public explainStatement(): ExplainStatementContext | undefined { + return this.tryGetRuleContext(0, ExplainStatementContext); + } + public setStatement(): SetStatementContext | undefined { + return this.tryGetRuleContext(0, SetStatementContext); + } + public shutdownStatement(): ShutdownStatementContext | undefined { + return this.tryGetRuleContext(0, ShutdownStatementContext); + } + public invalidateMetaStatement(): InvalidateMetaStatementContext | undefined { + return this.tryGetRuleContext(0, InvalidateMetaStatementContext); + } + public loadDataStatement(): LoadDataStatementContext | undefined { + return this.tryGetRuleContext(0, LoadDataStatementContext); + } + public refreshStatement(): RefreshStatementContext | undefined { + return this.tryGetRuleContext(0, RefreshStatementContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_statement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterStatement) { + listener.enterStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitStatement) { + listener.exitStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitStatement) { + return visitor.visitStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UseStatementContext extends ParserRuleContext { + public KW_USE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_USE, 0); } + public databaseNamePath(): DatabaseNamePathContext { + return this.getRuleContext(0, DatabaseNamePathContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_useStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterUseStatement) { + listener.enterUseStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitUseStatement) { + listener.exitUseStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitUseStatement) { + return visitor.visitUseStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateStatementContext extends ParserRuleContext { + public createSchema(): CreateSchemaContext | undefined { + return this.tryGetRuleContext(0, CreateSchemaContext); + } + public createRole(): CreateRoleContext | undefined { + return this.tryGetRuleContext(0, CreateRoleContext); + } + public createAggregateFunction(): CreateAggregateFunctionContext | undefined { + return this.tryGetRuleContext(0, CreateAggregateFunctionContext); + } + public createFunction(): CreateFunctionContext | undefined { + return this.tryGetRuleContext(0, CreateFunctionContext); + } + public createView(): CreateViewContext | undefined { + return this.tryGetRuleContext(0, CreateViewContext); + } + public createKuduTableAsSelect(): CreateKuduTableAsSelectContext | undefined { + return this.tryGetRuleContext(0, CreateKuduTableAsSelectContext); + } + public createTableLike(): CreateTableLikeContext | undefined { + return this.tryGetRuleContext(0, CreateTableLikeContext); + } + public createTableSelect(): CreateTableSelectContext | undefined { + return this.tryGetRuleContext(0, CreateTableSelectContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_createStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCreateStatement) { + listener.enterCreateStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCreateStatement) { + listener.exitCreateStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCreateStatement) { + return visitor.visitCreateStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateTableSelectContext extends ParserRuleContext { + public KW_CREATE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CREATE, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNameCreate(): TableNameCreateContext { + return this.getRuleContext(0, TableNameCreateContext); + } + public createCommonItem(): CreateCommonItemContext { + return this.getRuleContext(0, CreateCommonItemContext); + } + public KW_EXTERNAL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_EXTERNAL, 0); } + public ifNotExists(): IfNotExistsContext | undefined { + return this.tryGetRuleContext(0, IfNotExistsContext); + } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public columnDefinition(): ColumnDefinitionContext[]; + public columnDefinition(i: number): ColumnDefinitionContext; + public columnDefinition(i?: number): ColumnDefinitionContext | ColumnDefinitionContext[] { + if (i === undefined) { + return this.getRuleContexts(ColumnDefinitionContext); + } else { + return this.getRuleContext(i, ColumnDefinitionContext); + } + } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public KW_PARTITIONED(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITIONED, 0); } + public KW_BY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_BY, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_AS, 0); } + public queryStatement(): QueryStatementContext | undefined { + return this.tryGetRuleContext(0, QueryStatementContext); + } + public partitionedBy(): PartitionedByContext | undefined { + return this.tryGetRuleContext(0, PartitionedByContext); + } + public createColumnAliases(): CreateColumnAliasesContext | undefined { + return this.tryGetRuleContext(0, CreateColumnAliasesContext); + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + public constraintSpecification(): ConstraintSpecificationContext | undefined { + return this.tryGetRuleContext(0, ConstraintSpecificationContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_createTableSelect; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCreateTableSelect) { + listener.enterCreateTableSelect(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCreateTableSelect) { + listener.exitCreateTableSelect(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCreateTableSelect) { + return visitor.visitCreateTableSelect(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateTableLikeContext extends ParserRuleContext { + public _parquet!: StringLiteralContext; + public KW_CREATE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CREATE, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNameCreate(): TableNameCreateContext { + return this.getRuleContext(0, TableNameCreateContext); + } + public KW_LIKE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_LIKE, 0); } + public createCommonItem(): CreateCommonItemContext { + return this.getRuleContext(0, CreateCommonItemContext); + } + public tableNamePath(): TableNamePathContext | undefined { + return this.tryGetRuleContext(0, TableNamePathContext); + } + public KW_PARQUET(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARQUET, 0); } + public KW_EXTERNAL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_EXTERNAL, 0); } + public ifNotExists(): IfNotExistsContext | undefined { + return this.tryGetRuleContext(0, IfNotExistsContext); + } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + public KW_PARTITIONED(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITIONED, 0); } + public KW_BY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_BY, 0); } + public partitionedBy(): PartitionedByContext | undefined { + return this.tryGetRuleContext(0, PartitionedByContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_createTableLike; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCreateTableLike) { + listener.enterCreateTableLike(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCreateTableLike) { + listener.exitCreateTableLike(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCreateTableLike) { + return visitor.visitCreateTableLike(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateKuduTableAsSelectContext extends ParserRuleContext { + public _tblProp!: PropertiesContext; + public KW_CREATE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CREATE, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNameCreate(): TableNameCreateContext { + return this.getRuleContext(0, TableNameCreateContext); + } + public KW_STORED(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_STORED, 0); } + public KW_AS(): TerminalNode[]; + public KW_AS(i: number): TerminalNode; + public KW_AS(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.KW_AS); + } else { + return this.getToken(ImpalaSqlParser.KW_AS, i); + } + } + public KW_KUDU(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_KUDU, 0); } + public KW_EXTERNAL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_EXTERNAL, 0); } + public ifNotExists(): IfNotExistsContext | undefined { + return this.tryGetRuleContext(0, IfNotExistsContext); + } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public kuduTableElement(): KuduTableElementContext[]; + public kuduTableElement(i: number): KuduTableElementContext; + public kuduTableElement(i?: number): KuduTableElementContext | KuduTableElementContext[] { + if (i === undefined) { + return this.getRuleContexts(KuduTableElementContext); + } else { + return this.getRuleContext(i, KuduTableElementContext); + } + } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public KW_PRIMARY(): TerminalNode[]; + public KW_PRIMARY(i: number): TerminalNode; + public KW_PRIMARY(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.KW_PRIMARY); + } else { + return this.getToken(ImpalaSqlParser.KW_PRIMARY, i); + } + } + public KW_KEY(): TerminalNode[]; + public KW_KEY(i: number): TerminalNode; + public KW_KEY(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.KW_KEY); + } else { + return this.getToken(ImpalaSqlParser.KW_KEY, i); + } + } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITION, 0); } + public KW_BY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_BY, 0); } + public kuduPartitionClause(): KuduPartitionClauseContext | undefined { + return this.tryGetRuleContext(0, KuduPartitionClauseContext); + } + public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COMMENT, 0); } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + public KW_TBLPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TBLPROPERTIES, 0); } + public queryStatement(): QueryStatementContext | undefined { + return this.tryGetRuleContext(0, QueryStatementContext); + } + public properties(): PropertiesContext | undefined { + return this.tryGetRuleContext(0, PropertiesContext); + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + public columnAliases(): ColumnAliasesContext[]; + public columnAliases(i: number): ColumnAliasesContext; + public columnAliases(i?: number): ColumnAliasesContext | ColumnAliasesContext[] { + if (i === undefined) { + return this.getRuleContexts(ColumnAliasesContext); + } else { + return this.getRuleContext(i, ColumnAliasesContext); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_createKuduTableAsSelect; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCreateKuduTableAsSelect) { + listener.enterCreateKuduTableAsSelect(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCreateKuduTableAsSelect) { + listener.exitCreateKuduTableAsSelect(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCreateKuduTableAsSelect) { + return visitor.visitCreateKuduTableAsSelect(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateViewContext extends ParserRuleContext { + public _tblProp!: PropertiesContext; + public KW_CREATE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CREATE, 0); } + public KW_VIEW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_VIEW, 0); } + public viewNameCreate(): ViewNameCreateContext { + return this.getRuleContext(0, ViewNameCreateContext); + } + public KW_AS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_AS, 0); } + public queryStatement(): QueryStatementContext { + return this.getRuleContext(0, QueryStatementContext); + } + public ifNotExists(): IfNotExistsContext | undefined { + return this.tryGetRuleContext(0, IfNotExistsContext); + } + public viewColumns(): ViewColumnsContext | undefined { + return this.tryGetRuleContext(0, ViewColumnsContext); + } + public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COMMENT, 0); } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + public KW_TBLPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TBLPROPERTIES, 0); } + public properties(): PropertiesContext | undefined { + return this.tryGetRuleContext(0, PropertiesContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_createView; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCreateView) { + listener.enterCreateView(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCreateView) { + listener.exitCreateView(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCreateView) { + return visitor.visitCreateView(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateSchemaContext extends ParserRuleContext { + public _comment!: StringLiteralContext; + public _location!: StringLiteralContext; + public KW_CREATE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CREATE, 0); } + public databaseNameCreate(): DatabaseNameCreateContext { + return this.getRuleContext(0, DatabaseNameCreateContext); + } + public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SCHEMA, 0); } + public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DATABASE, 0); } + public ifNotExists(): IfNotExistsContext | undefined { + return this.tryGetRuleContext(0, IfNotExistsContext); + } + public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COMMENT, 0); } + public KW_LOCATION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LOCATION, 0); } + public stringLiteral(): StringLiteralContext[]; + public stringLiteral(i: number): StringLiteralContext; + public stringLiteral(i?: number): StringLiteralContext | StringLiteralContext[] { + if (i === undefined) { + return this.getRuleContexts(StringLiteralContext); + } else { + return this.getRuleContext(i, StringLiteralContext); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_createSchema; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCreateSchema) { + listener.enterCreateSchema(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCreateSchema) { + listener.exitCreateSchema(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCreateSchema) { + return visitor.visitCreateSchema(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateRoleContext extends ParserRuleContext { + public _name!: IdentifierContext; + public KW_CREATE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CREATE, 0); } + public KW_ROLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ROLE, 0); } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_createRole; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCreateRole) { + listener.enterCreateRole(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCreateRole) { + listener.exitCreateRole(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCreateRole) { + return visitor.visitCreateRole(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateAggregateFunctionContext extends ParserRuleContext { + public KW_CREATE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CREATE, 0); } + public KW_FUNCTION(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_FUNCTION, 0); } + public functionNameCreate(): FunctionNameCreateContext { + return this.getRuleContext(0, FunctionNameCreateContext); + } + public KW_RETURNS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_RETURNS, 0); } + public type(): TypeContext[]; + public type(i: number): TypeContext; + public type(i?: number): TypeContext | TypeContext[] { + if (i === undefined) { + return this.getRuleContexts(TypeContext); + } else { + return this.getRuleContext(i, TypeContext); + } + } + public KW_LOCATION(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_LOCATION, 0); } + public STRING(): TerminalNode[]; + public STRING(i: number): TerminalNode; + public STRING(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.STRING); + } else { + return this.getToken(ImpalaSqlParser.STRING, i); + } + } + public KW_UPDATE_FN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_UPDATE_FN, 0); } + public EQ(): TerminalNode[]; + public EQ(i: number): TerminalNode; + public EQ(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.EQ); + } else { + return this.getToken(ImpalaSqlParser.EQ, i); + } + } + public KW_MERGE_FN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_MERGE_FN, 0); } + public KW_AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_AGGREGATE, 0); } + public ifNotExists(): IfNotExistsContext | undefined { + return this.tryGetRuleContext(0, IfNotExistsContext); + } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public KW_INTERMEDIATE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_INTERMEDIATE, 0); } + public KW_INIT_FN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_INIT_FN, 0); } + public KW_PREPARE_FN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PREPARE_FN, 0); } + public KW_CLOSEFN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_CLOSEFN, 0); } + public KW_SERIALIZE_FN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SERIALIZE_FN, 0); } + public KW_FINALIZE_FN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FINALIZE_FN, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_createAggregateFunction; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCreateAggregateFunction) { + listener.enterCreateAggregateFunction(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCreateAggregateFunction) { + listener.exitCreateAggregateFunction(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCreateAggregateFunction) { + return visitor.visitCreateAggregateFunction(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateFunctionContext extends ParserRuleContext { + public _symbol!: StringLiteralContext; + public KW_CREATE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CREATE, 0); } + public KW_FUNCTION(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_FUNCTION, 0); } + public functionNameCreate(): FunctionNameCreateContext { + return this.getRuleContext(0, FunctionNameCreateContext); + } + public KW_LOCATION(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_LOCATION, 0); } + public STRING(): TerminalNode { return this.getToken(ImpalaSqlParser.STRING, 0); } + public KW_SYMBOL(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SYMBOL, 0); } + public EQ(): TerminalNode { return this.getToken(ImpalaSqlParser.EQ, 0); } + public stringLiteral(): StringLiteralContext { + return this.getRuleContext(0, StringLiteralContext); + } + public ifNotExists(): IfNotExistsContext | undefined { + return this.tryGetRuleContext(0, IfNotExistsContext); + } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public KW_RETURNS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RETURNS, 0); } + public type(): TypeContext[]; + public type(i: number): TypeContext; + public type(i?: number): TypeContext | TypeContext[] { + if (i === undefined) { + return this.getRuleContexts(TypeContext); + } else { + return this.getRuleContext(i, TypeContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_createFunction; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCreateFunction) { + listener.enterCreateFunction(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCreateFunction) { + listener.exitCreateFunction(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCreateFunction) { + return visitor.visitCreateFunction(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AlterStatementContext extends ParserRuleContext { + public alterDatabase(): AlterDatabaseContext | undefined { + return this.tryGetRuleContext(0, AlterDatabaseContext); + } + public alterUnSetOrSetViewTblproperties(): AlterUnSetOrSetViewTblpropertiesContext | undefined { + return this.tryGetRuleContext(0, AlterUnSetOrSetViewTblpropertiesContext); + } + public renameTable(): RenameTableContext | undefined { + return this.tryGetRuleContext(0, RenameTableContext); + } + public alterViewOwner(): AlterViewOwnerContext | undefined { + return this.tryGetRuleContext(0, AlterViewOwnerContext); + } + public alterView(): AlterViewContext | undefined { + return this.tryGetRuleContext(0, AlterViewContext); + } + public renameView(): RenameViewContext | undefined { + return this.tryGetRuleContext(0, RenameViewContext); + } + public dropPartitionByRangeOrValue(): DropPartitionByRangeOrValueContext | undefined { + return this.tryGetRuleContext(0, DropPartitionByRangeOrValueContext); + } + public alterFormat(): AlterFormatContext | undefined { + return this.tryGetRuleContext(0, AlterFormatContext); + } + public recoverPartitions(): RecoverPartitionsContext | undefined { + return this.tryGetRuleContext(0, RecoverPartitionsContext); + } + public addPartitionByRangeOrValue(): AddPartitionByRangeOrValueContext | undefined { + return this.tryGetRuleContext(0, AddPartitionByRangeOrValueContext); + } + public alterTableNonKuduOrKuduOnly(): AlterTableNonKuduOrKuduOnlyContext | undefined { + return this.tryGetRuleContext(0, AlterTableNonKuduOrKuduOnlyContext); + } + public addSingleColumn(): AddSingleColumnContext | undefined { + return this.tryGetRuleContext(0, AddSingleColumnContext); + } + public replaceOrAddColumns(): ReplaceOrAddColumnsContext | undefined { + return this.tryGetRuleContext(0, ReplaceOrAddColumnsContext); + } + public changeColumnDefine(): ChangeColumnDefineContext | undefined { + return this.tryGetRuleContext(0, ChangeColumnDefineContext); + } + public alterStatsKey(): AlterStatsKeyContext | undefined { + return this.tryGetRuleContext(0, AlterStatsKeyContext); + } + public alterPartitionCache(): AlterPartitionCacheContext | undefined { + return this.tryGetRuleContext(0, AlterPartitionCacheContext); + } + public alterDropSingleColumn(): AlterDropSingleColumnContext | undefined { + return this.tryGetRuleContext(0, AlterDropSingleColumnContext); + } + public alterTableOwner(): AlterTableOwnerContext | undefined { + return this.tryGetRuleContext(0, AlterTableOwnerContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_alterStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAlterStatement) { + listener.enterAlterStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAlterStatement) { + listener.exitAlterStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAlterStatement) { + return visitor.visitAlterStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AlterDatabaseContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_DATABASE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DATABASE, 0); } + public databaseNamePath(): DatabaseNamePathContext { + return this.getRuleContext(0, DatabaseNamePathContext); + } + public KW_SET(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SET, 0); } + public KW_OWNER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_OWNER, 0); } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_USER, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROLE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_alterDatabase; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAlterDatabase) { + listener.enterAlterDatabase(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAlterDatabase) { + listener.exitAlterDatabase(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAlterDatabase) { + return visitor.visitAlterDatabase(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AlterStatsKeyContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_SET(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SET, 0); } + public KW_COLUMN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_COLUMN, 0); } + public KW_STATS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_STATS, 0); } + public columnNamePath(): ColumnNamePathContext { + return this.getRuleContext(0, ColumnNamePathContext); + } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public statsKey(): StatsKeyContext[]; + public statsKey(i: number): StatsKeyContext; + public statsKey(i?: number): StatsKeyContext | StatsKeyContext[] { + if (i === undefined) { + return this.getRuleContexts(StatsKeyContext); + } else { + return this.getRuleContext(i, StatsKeyContext); + } + } + public EQ(): TerminalNode[]; + public EQ(i: number): TerminalNode; + public EQ(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.EQ); + } else { + return this.getToken(ImpalaSqlParser.EQ, i); + } + } + public stringLiteral(): StringLiteralContext[]; + public stringLiteral(i: number): StringLiteralContext; + public stringLiteral(i?: number): StringLiteralContext | StringLiteralContext[] { + if (i === undefined) { + return this.getRuleContexts(StringLiteralContext); + } else { + return this.getRuleContext(i, StringLiteralContext); + } + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public COMMA(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.COMMA, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_alterStatsKey; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAlterStatsKey) { + listener.enterAlterStatsKey(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAlterStatsKey) { + listener.exitAlterStatsKey(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAlterStatsKey) { + return visitor.visitAlterStatsKey(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AlterPartitionCacheContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_SET(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SET, 0); } + public KW_UNCACHED(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_UNCACHED, 0); } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITION, 0); } + public expression(): ExpressionContext | undefined { + return this.tryGetRuleContext(0, ExpressionContext); + } + public KW_CACHED(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_CACHED, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_IN, 0); } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_WITH, 0); } + public KW_REPLICATION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_REPLICATION, 0); } + public EQ(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.EQ, 0); } + public number(): NumberContext | undefined { + return this.tryGetRuleContext(0, NumberContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_alterPartitionCache; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAlterPartitionCache) { + listener.enterAlterPartitionCache(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAlterPartitionCache) { + listener.exitAlterPartitionCache(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAlterPartitionCache) { + return visitor.visitAlterPartitionCache(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ChangeColumnDefineContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_CHANGE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CHANGE, 0); } + public KW_COLUMN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_COLUMN, 0); } + public columnSpecWithKudu(): ColumnSpecWithKuduContext { + return this.getRuleContext(0, ColumnSpecWithKuduContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_changeColumnDefine; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterChangeColumnDefine) { + listener.enterChangeColumnDefine(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitChangeColumnDefine) { + listener.exitChangeColumnDefine(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitChangeColumnDefine) { + return visitor.visitChangeColumnDefine(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AlterDropSingleColumnContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_DROP(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DROP, 0); } + public columnNamePath(): ColumnNamePathContext { + return this.getRuleContext(0, ColumnNamePathContext); + } + public KW_COLUMN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COLUMN, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_alterDropSingleColumn; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAlterDropSingleColumn) { + listener.enterAlterDropSingleColumn(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAlterDropSingleColumn) { + listener.exitAlterDropSingleColumn(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAlterDropSingleColumn) { + return visitor.visitAlterDropSingleColumn(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AlterTableOwnerContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_SET(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SET, 0); } + public KW_OWNER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_OWNER, 0); } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_USER, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROLE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_alterTableOwner; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAlterTableOwner) { + listener.enterAlterTableOwner(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAlterTableOwner) { + listener.exitAlterTableOwner(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAlterTableOwner) { + return visitor.visitAlterTableOwner(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ReplaceOrAddColumnsContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_COLUMNS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_COLUMNS, 0); } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public columnSpecWithKudu(): ColumnSpecWithKuduContext[]; + public columnSpecWithKudu(i: number): ColumnSpecWithKuduContext; + public columnSpecWithKudu(i?: number): ColumnSpecWithKuduContext | ColumnSpecWithKuduContext[] { + if (i === undefined) { + return this.getRuleContexts(ColumnSpecWithKuduContext); + } else { + return this.getRuleContext(i, ColumnSpecWithKuduContext); + } + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_REPLACE, 0); } + public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ADD, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + public ifNotExists(): IfNotExistsContext | undefined { + return this.tryGetRuleContext(0, IfNotExistsContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_replaceOrAddColumns; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterReplaceOrAddColumns) { + listener.enterReplaceOrAddColumns(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitReplaceOrAddColumns) { + listener.exitReplaceOrAddColumns(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitReplaceOrAddColumns) { + return visitor.visitReplaceOrAddColumns(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AddSingleColumnContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_ADD(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ADD, 0); } + public KW_COLUMN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_COLUMN, 0); } + public createColumnSpecWithKudu(): CreateColumnSpecWithKuduContext { + return this.getRuleContext(0, CreateColumnSpecWithKuduContext); + } + public ifNotExists(): IfNotExistsContext | undefined { + return this.tryGetRuleContext(0, IfNotExistsContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_addSingleColumn; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAddSingleColumn) { + listener.enterAddSingleColumn(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAddSingleColumn) { + listener.exitAddSingleColumn(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAddSingleColumn) { + return visitor.visitAddSingleColumn(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AlterTableNonKuduOrKuduOnlyContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode[]; + public KW_ALTER(i: number): TerminalNode; + public KW_ALTER(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.KW_ALTER); + } else { + return this.getToken(ImpalaSqlParser.KW_ALTER, i); + } + } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public columnNamePath(): ColumnNamePathContext { + return this.getRuleContext(0, ColumnNamePathContext); + } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SET, 0); } + public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DROP, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DEFAULT, 0); } + public KW_COLUMN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COLUMN, 0); } + public kuduStorageAttr(): KuduStorageAttrContext | undefined { + return this.tryGetRuleContext(0, KuduStorageAttrContext); + } + public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COMMENT, 0); } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_alterTableNonKuduOrKuduOnly; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAlterTableNonKuduOrKuduOnly) { + listener.enterAlterTableNonKuduOrKuduOnly(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAlterTableNonKuduOrKuduOnly) { + listener.exitAlterTableNonKuduOrKuduOnly(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAlterTableNonKuduOrKuduOnly) { + return visitor.visitAlterTableNonKuduOrKuduOnly(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AddPartitionByRangeOrValueContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_ADD(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ADD, 0); } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITION, 0); } + public expression(): ExpressionContext | undefined { + return this.tryGetRuleContext(0, ExpressionContext); + } + public KW_RANGE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RANGE, 0); } + public kuduPartitionSpec(): KuduPartitionSpecContext | undefined { + return this.tryGetRuleContext(0, KuduPartitionSpecContext); + } + public ifNotExists(): IfNotExistsContext | undefined { + return this.tryGetRuleContext(0, IfNotExistsContext); + } + public KW_LOCATION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LOCATION, 0); } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + public cacheSpec(): CacheSpecContext | undefined { + return this.tryGetRuleContext(0, CacheSpecContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_addPartitionByRangeOrValue; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAddPartitionByRangeOrValue) { + listener.enterAddPartitionByRangeOrValue(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAddPartitionByRangeOrValue) { + listener.exitAddPartitionByRangeOrValue(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAddPartitionByRangeOrValue) { + return visitor.visitAddPartitionByRangeOrValue(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AlterFormatContext extends ParserRuleContext { + public _tblProp!: PropertiesContext; + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_SET(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SET, 0); } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITION, 0); } + public expression(): ExpressionContext | undefined { + return this.tryGetRuleContext(0, ExpressionContext); + } + public KW_FILEFORMAT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FILEFORMAT, 0); } + public fileFormat(): FileFormatContext | undefined { + return this.tryGetRuleContext(0, FileFormatContext); + } + public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROW, 0); } + public KW_FORMAT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FORMAT, 0); } + public rowFormat(): RowFormatContext | undefined { + return this.tryGetRuleContext(0, RowFormatContext); + } + public KW_LOCATION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LOCATION, 0); } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + public KW_TBLPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TBLPROPERTIES, 0); } + public KW_SERDEPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SERDEPROPERTIES, 0); } + public properties(): PropertiesContext | undefined { + return this.tryGetRuleContext(0, PropertiesContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_alterFormat; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAlterFormat) { + listener.enterAlterFormat(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAlterFormat) { + listener.exitAlterFormat(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAlterFormat) { + return visitor.visitAlterFormat(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RecoverPartitionsContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_RECOVER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_RECOVER, 0); } + public KW_PARTITIONS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_PARTITIONS, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_recoverPartitions; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRecoverPartitions) { + listener.enterRecoverPartitions(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRecoverPartitions) { + listener.exitRecoverPartitions(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRecoverPartitions) { + return visitor.visitRecoverPartitions(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DropPartitionByRangeOrValueContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_DROP(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DROP, 0); } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITION, 0); } + public expression(): ExpressionContext | undefined { + return this.tryGetRuleContext(0, ExpressionContext); + } + public KW_RANGE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RANGE, 0); } + public kuduPartitionSpec(): KuduPartitionSpecContext | undefined { + return this.tryGetRuleContext(0, KuduPartitionSpecContext); + } + public ifExists(): IfExistsContext | undefined { + return this.tryGetRuleContext(0, IfExistsContext); + } + public KW_PURGE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PURGE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_dropPartitionByRangeOrValue; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDropPartitionByRangeOrValue) { + listener.enterDropPartitionByRangeOrValue(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDropPartitionByRangeOrValue) { + listener.exitDropPartitionByRangeOrValue(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDropPartitionByRangeOrValue) { + return visitor.visitDropPartitionByRangeOrValue(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AlterViewContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_VIEW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_VIEW, 0); } + public viewNamePath(): ViewNamePathContext { + return this.getRuleContext(0, ViewNamePathContext); + } + public KW_AS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_AS, 0); } + public queryStatement(): QueryStatementContext { + return this.getRuleContext(0, QueryStatementContext); + } + public viewColumns(): ViewColumnsContext | undefined { + return this.tryGetRuleContext(0, ViewColumnsContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_alterView; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAlterView) { + listener.enterAlterView(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAlterView) { + listener.exitAlterView(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAlterView) { + return visitor.visitAlterView(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RenameViewContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_VIEW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_VIEW, 0); } + public viewNamePath(): ViewNamePathContext[]; + public viewNamePath(i: number): ViewNamePathContext; + public viewNamePath(i?: number): ViewNamePathContext | ViewNamePathContext[] { + if (i === undefined) { + return this.getRuleContexts(ViewNamePathContext); + } else { + return this.getRuleContext(i, ViewNamePathContext); + } + } + public KW_RENAME(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_RENAME, 0); } + public KW_TO(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TO, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_renameView; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRenameView) { + listener.enterRenameView(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRenameView) { + listener.exitRenameView(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRenameView) { + return visitor.visitRenameView(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AlterViewOwnerContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_VIEW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_VIEW, 0); } + public viewNamePath(): ViewNamePathContext { + return this.getRuleContext(0, ViewNamePathContext); + } + public KW_SET(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SET, 0); } + public KW_OWNER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_OWNER, 0); } + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext); + } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_USER, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROLE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_alterViewOwner; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAlterViewOwner) { + listener.enterAlterViewOwner(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAlterViewOwner) { + listener.exitAlterViewOwner(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAlterViewOwner) { + return visitor.visitAlterViewOwner(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RenameTableContext extends ParserRuleContext { + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext[]; + public tableNamePath(i: number): TableNamePathContext; + public tableNamePath(i?: number): TableNamePathContext | TableNamePathContext[] { + if (i === undefined) { + return this.getRuleContexts(TableNamePathContext); + } else { + return this.getRuleContext(i, TableNamePathContext); + } + } + public KW_RENAME(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_RENAME, 0); } + public KW_TO(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TO, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_renameTable; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRenameTable) { + listener.enterRenameTable(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRenameTable) { + listener.exitRenameTable(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRenameTable) { + return visitor.visitRenameTable(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AlterUnSetOrSetViewTblpropertiesContext extends ParserRuleContext { + public _tblProp!: PropertiesContext; + public KW_ALTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_VIEW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_VIEW, 0); } + public viewNamePath(): ViewNamePathContext { + return this.getRuleContext(0, ViewNamePathContext); + } + public KW_TBLPROPERTIES(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TBLPROPERTIES, 0); } + public KW_UNSET(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_UNSET, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SET, 0); } + public properties(): PropertiesContext { + return this.getRuleContext(0, PropertiesContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_alterUnSetOrSetViewTblproperties; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAlterUnSetOrSetViewTblproperties) { + listener.enterAlterUnSetOrSetViewTblproperties(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAlterUnSetOrSetViewTblproperties) { + listener.exitAlterUnSetOrSetViewTblproperties(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAlterUnSetOrSetViewTblproperties) { + return visitor.visitAlterUnSetOrSetViewTblproperties(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TruncateTableStatementContext extends ParserRuleContext { + public KW_TRUNCATE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TRUNCATE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TABLE, 0); } + public ifExists(): IfExistsContext | undefined { + return this.tryGetRuleContext(0, IfExistsContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_truncateTableStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterTruncateTableStatement) { + listener.enterTruncateTableStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitTruncateTableStatement) { + listener.exitTruncateTableStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitTruncateTableStatement) { + return visitor.visitTruncateTableStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DescribeStatementContext extends ParserRuleContext { + public KW_DESCRIBE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DESCRIBE, 0); } + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext); + } + public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DATABASE, 0); } + public KW_FORMATTED(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FORMATTED, 0); } + public KW_EXTENDED(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_EXTENDED, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_describeStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDescribeStatement) { + listener.enterDescribeStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDescribeStatement) { + listener.exitDescribeStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDescribeStatement) { + return visitor.visitDescribeStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ComputeStatementContext extends ParserRuleContext { + public computeStats(): ComputeStatsContext | undefined { + return this.tryGetRuleContext(0, ComputeStatsContext); + } + public computeIncrementalStats(): ComputeIncrementalStatsContext | undefined { + return this.tryGetRuleContext(0, ComputeIncrementalStatsContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_computeStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterComputeStatement) { + listener.enterComputeStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitComputeStatement) { + listener.exitComputeStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitComputeStatement) { + return visitor.visitComputeStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ComputeStatsContext extends ParserRuleContext { + public KW_COMPUTE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_COMPUTE, 0); } + public KW_STATS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_STATS, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public columnAliases(): ColumnAliasesContext | undefined { + return this.tryGetRuleContext(0, ColumnAliasesContext); + } + public KW_TABLESAMPLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TABLESAMPLE, 0); } + public KW_SYSTEM(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SYSTEM, 0); } + public LPAREN(): TerminalNode[]; + public LPAREN(i: number): TerminalNode; + public LPAREN(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.LPAREN); + } else { + return this.getToken(ImpalaSqlParser.LPAREN, i); + } + } + public number(): NumberContext[]; + public number(i: number): NumberContext; + public number(i?: number): NumberContext | NumberContext[] { + if (i === undefined) { + return this.getRuleContexts(NumberContext); + } else { + return this.getRuleContext(i, NumberContext); + } + } + public RPAREN(): TerminalNode[]; + public RPAREN(i: number): TerminalNode; + public RPAREN(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.RPAREN); + } else { + return this.getToken(ImpalaSqlParser.RPAREN, i); + } + } + public KW_REPEATABLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_REPEATABLE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_computeStats; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterComputeStats) { + listener.enterComputeStats(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitComputeStats) { + listener.exitComputeStats(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitComputeStats) { + return visitor.visitComputeStats(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ComputeIncrementalStatsContext extends ParserRuleContext { + public KW_COMPUTE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_COMPUTE, 0); } + public KW_INCREMENTAL(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_INCREMENTAL, 0); } + public KW_STATS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_STATS, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITION, 0); } + public expression(): ExpressionContext | undefined { + return this.tryGetRuleContext(0, ExpressionContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_computeIncrementalStats; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterComputeIncrementalStats) { + listener.enterComputeIncrementalStats(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitComputeIncrementalStats) { + listener.exitComputeIncrementalStats(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitComputeIncrementalStats) { + return visitor.visitComputeIncrementalStats(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DropStatementContext extends ParserRuleContext { + public dropRole(): DropRoleContext | undefined { + return this.tryGetRuleContext(0, DropRoleContext); + } + public dropFunction(): DropFunctionContext | undefined { + return this.tryGetRuleContext(0, DropFunctionContext); + } + public dropIncrementalStats(): DropIncrementalStatsContext | undefined { + return this.tryGetRuleContext(0, DropIncrementalStatsContext); + } + public dropView(): DropViewContext | undefined { + return this.tryGetRuleContext(0, DropViewContext); + } + public dropTable(): DropTableContext | undefined { + return this.tryGetRuleContext(0, DropTableContext); + } + public dropSchema(): DropSchemaContext | undefined { + return this.tryGetRuleContext(0, DropSchemaContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_dropStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDropStatement) { + listener.enterDropStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDropStatement) { + listener.exitDropStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDropStatement) { + return visitor.visitDropStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DropSchemaContext extends ParserRuleContext { + public KW_DROP(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DROP, 0); } + public databaseNamePath(): DatabaseNamePathContext { + return this.getRuleContext(0, DatabaseNamePathContext); + } + public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SCHEMA, 0); } + public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DATABASE, 0); } + public ifExists(): IfExistsContext | undefined { + return this.tryGetRuleContext(0, IfExistsContext); + } + public KW_CASCADE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_CASCADE, 0); } + public KW_RESTRICT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RESTRICT, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_dropSchema; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDropSchema) { + listener.enterDropSchema(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDropSchema) { + listener.exitDropSchema(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDropSchema) { + return visitor.visitDropSchema(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DropViewContext extends ParserRuleContext { + public KW_DROP(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DROP, 0); } + public KW_VIEW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_VIEW, 0); } + public viewNamePath(): ViewNamePathContext { + return this.getRuleContext(0, ViewNamePathContext); + } + public ifExists(): IfExistsContext | undefined { + return this.tryGetRuleContext(0, IfExistsContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_dropView; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDropView) { + listener.enterDropView(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDropView) { + listener.exitDropView(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDropView) { + return visitor.visitDropView(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DropTableContext extends ParserRuleContext { + public KW_DROP(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DROP, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public ifExists(): IfExistsContext | undefined { + return this.tryGetRuleContext(0, IfExistsContext); + } + public KW_PURGE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PURGE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_dropTable; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDropTable) { + listener.enterDropTable(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDropTable) { + listener.exitDropTable(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDropTable) { + return visitor.visitDropTable(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DropIncrementalStatsContext extends ParserRuleContext { + public KW_DROP(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DROP, 0); } + public KW_STATS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_STATS, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_INCREMENTAL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_INCREMENTAL, 0); } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITION, 0); } + public expression(): ExpressionContext | undefined { + return this.tryGetRuleContext(0, ExpressionContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_dropIncrementalStats; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDropIncrementalStats) { + listener.enterDropIncrementalStats(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDropIncrementalStats) { + listener.exitDropIncrementalStats(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDropIncrementalStats) { + return visitor.visitDropIncrementalStats(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DropFunctionContext extends ParserRuleContext { + public KW_DROP(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DROP, 0); } + public KW_FUNCTION(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_FUNCTION, 0); } + public functionNamePath(): FunctionNamePathContext { + return this.getRuleContext(0, FunctionNamePathContext); + } + public KW_AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_AGGREGATE, 0); } + public ifExists(): IfExistsContext | undefined { + return this.tryGetRuleContext(0, IfExistsContext); + } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public type(): TypeContext[]; + public type(i: number): TypeContext; + public type(i?: number): TypeContext | TypeContext[] { + if (i === undefined) { + return this.getRuleContexts(TypeContext); + } else { + return this.getRuleContext(i, TypeContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_dropFunction; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDropFunction) { + listener.enterDropFunction(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDropFunction) { + listener.exitDropFunction(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDropFunction) { + return visitor.visitDropFunction(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DropRoleContext extends ParserRuleContext { + public _name!: IdentifierContext; + public KW_DROP(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DROP, 0); } + public KW_ROLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ROLE, 0); } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_dropRole; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDropRole) { + listener.enterDropRole(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDropRole) { + listener.exitDropRole(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDropRole) { + return visitor.visitDropRole(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class GrantStatementContext extends ParserRuleContext { + public grantRole(): GrantRoleContext | undefined { + return this.tryGetRuleContext(0, GrantRoleContext); + } + public grant(): GrantContext | undefined { + return this.tryGetRuleContext(0, GrantContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_grantStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterGrantStatement) { + listener.enterGrantStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitGrantStatement) { + listener.exitGrantStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitGrantStatement) { + return visitor.visitGrantStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class GrantRoleContext extends ParserRuleContext { + public KW_GRANT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_GRANT, 0); } + public KW_ROLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ROLE, 0); } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext; + public identifier(i?: number): IdentifierContext | IdentifierContext[] { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } else { + return this.getRuleContext(i, IdentifierContext); + } + } + public KW_TO(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TO, 0); } + public KW_GROUP(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_GROUP, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_grantRole; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterGrantRole) { + listener.enterGrantRole(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitGrantRole) { + listener.exitGrantRole(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitGrantRole) { + return visitor.visitGrantRole(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class GrantContext extends ParserRuleContext { + public _grantee!: PrincipalContext; + public KW_GRANT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_GRANT, 0); } + public privilege(): PrivilegeContext { + return this.getRuleContext(0, PrivilegeContext); + } + public KW_ON(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ON, 0); } + public objectType(): ObjectTypeContext { + return this.getRuleContext(0, ObjectTypeContext); + } + public KW_TO(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TO, 0); } + public principal(): PrincipalContext { + return this.getRuleContext(0, PrincipalContext); + } + public qualifiedName(): QualifiedNameContext | undefined { + return this.tryGetRuleContext(0, QualifiedNameContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_grant; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterGrant) { + listener.enterGrant(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitGrant) { + listener.exitGrant(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitGrant) { + return visitor.visitGrant(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RevokeStatementContext extends ParserRuleContext { + public revokeRole(): RevokeRoleContext | undefined { + return this.tryGetRuleContext(0, RevokeRoleContext); + } + public revoke(): RevokeContext | undefined { + return this.tryGetRuleContext(0, RevokeContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_revokeStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRevokeStatement) { + listener.enterRevokeStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRevokeStatement) { + listener.exitRevokeStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRevokeStatement) { + return visitor.visitRevokeStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RevokeRoleContext extends ParserRuleContext { + public KW_REVOKE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_REVOKE, 0); } + public KW_ROLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ROLE, 0); } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext; + public identifier(i?: number): IdentifierContext | IdentifierContext[] { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } else { + return this.getRuleContext(i, IdentifierContext); + } + } + public KW_FROM(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_FROM, 0); } + public KW_GROUP(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_GROUP, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_revokeRole; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRevokeRole) { + listener.enterRevokeRole(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRevokeRole) { + listener.exitRevokeRole(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRevokeRole) { + return visitor.visitRevokeRole(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RevokeContext extends ParserRuleContext { + public _grantee!: PrincipalContext; + public KW_REVOKE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_REVOKE, 0); } + public privilege(): PrivilegeContext { + return this.getRuleContext(0, PrivilegeContext); + } + public KW_ON(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ON, 0); } + public objectType(): ObjectTypeContext { + return this.getRuleContext(0, ObjectTypeContext); + } + public KW_FROM(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_FROM, 0); } + public identifier(): IdentifierContext | undefined { + return this.tryGetRuleContext(0, IdentifierContext); + } + public KW_GRANT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_GRANT, 0); } + public KW_OPTION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_OPTION, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FOR, 0); } + public qualifiedName(): QualifiedNameContext | undefined { + return this.tryGetRuleContext(0, QualifiedNameContext); + } + public principal(): PrincipalContext | undefined { + return this.tryGetRuleContext(0, PrincipalContext); + } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROLE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_revoke; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRevoke) { + listener.enterRevoke(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRevoke) { + listener.exitRevoke(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRevoke) { + return visitor.visitRevoke(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class InsertStatementContext extends ParserRuleContext { + public KW_INSERT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_INSERT, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public queryStatement(): QueryStatementContext { + return this.getRuleContext(0, QueryStatementContext); + } + public KW_INTO(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_INTO, 0); } + public KW_OVERWRITE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_OVERWRITE, 0); } + public with(): WithContext | undefined { + return this.tryGetRuleContext(0, WithContext); + } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TABLE, 0); } + public columnAliases(): ColumnAliasesContext | undefined { + return this.tryGetRuleContext(0, ColumnAliasesContext); + } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITION, 0); } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_insertStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterInsertStatement) { + listener.enterInsertStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitInsertStatement) { + listener.exitInsertStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitInsertStatement) { + return visitor.visitInsertStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DeleteStatementContext extends ParserRuleContext { + public delete(): DeleteContext | undefined { + return this.tryGetRuleContext(0, DeleteContext); + } + public deleteTableRef(): DeleteTableRefContext | undefined { + return this.tryGetRuleContext(0, DeleteTableRefContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_deleteStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDeleteStatement) { + listener.enterDeleteStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDeleteStatement) { + listener.exitDeleteStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDeleteStatement) { + return visitor.visitDeleteStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DeleteContext extends ParserRuleContext { + public KW_DELETE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DELETE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FROM, 0); } + public KW_WHERE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_WHERE, 0); } + public booleanExpression(): BooleanExpressionContext | undefined { + return this.tryGetRuleContext(0, BooleanExpressionContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_delete; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDelete) { + listener.enterDelete(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDelete) { + listener.exitDelete(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDelete) { + return visitor.visitDelete(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DeleteTableRefContext extends ParserRuleContext { + public KW_DELETE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DELETE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_FROM(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_FROM, 0); } + public identifier(): IdentifierContext | undefined { + return this.tryGetRuleContext(0, IdentifierContext); + } + public relation(): RelationContext[]; + public relation(i: number): RelationContext; + public relation(i?: number): RelationContext | RelationContext[] { + if (i === undefined) { + return this.getRuleContexts(RelationContext); + } else { + return this.getRuleContext(i, RelationContext); + } + } + public KW_WHERE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_WHERE, 0); } + public booleanExpression(): BooleanExpressionContext | undefined { + return this.tryGetRuleContext(0, BooleanExpressionContext); + } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_AS, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_deleteTableRef; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDeleteTableRef) { + listener.enterDeleteTableRef(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDeleteTableRef) { + listener.exitDeleteTableRef(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDeleteTableRef) { + return visitor.visitDeleteTableRef(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UpdateStatementContext extends ParserRuleContext { + public KW_UPDATE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_UPDATE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_SET(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SET, 0); } + public assignmentList(): AssignmentListContext { + return this.getRuleContext(0, AssignmentListContext); + } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FROM, 0); } + public relation(): RelationContext[]; + public relation(i: number): RelationContext; + public relation(i?: number): RelationContext | RelationContext[] { + if (i === undefined) { + return this.getRuleContexts(RelationContext); + } else { + return this.getRuleContext(i, RelationContext); + } + } + public KW_WHERE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_WHERE, 0); } + public booleanExpression(): BooleanExpressionContext | undefined { + return this.tryGetRuleContext(0, BooleanExpressionContext); + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_updateStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterUpdateStatement) { + listener.enterUpdateStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitUpdateStatement) { + listener.exitUpdateStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitUpdateStatement) { + return visitor.visitUpdateStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UpsertStatementContext extends ParserRuleContext { + public KW_UPSERT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_UPSERT, 0); } + public KW_INTO(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_INTO, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public queryStatement(): QueryStatementContext { + return this.getRuleContext(0, QueryStatementContext); + } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TABLE, 0); } + public columnAliases(): ColumnAliasesContext | undefined { + return this.tryGetRuleContext(0, ColumnAliasesContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_upsertStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterUpsertStatement) { + listener.enterUpsertStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitUpsertStatement) { + listener.exitUpsertStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitUpsertStatement) { + return visitor.visitUpsertStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowStatementContext extends ParserRuleContext { + public showRoles(): ShowRolesContext | undefined { + return this.tryGetRuleContext(0, ShowRolesContext); + } + public showRoleGrant(): ShowRoleGrantContext | undefined { + return this.tryGetRuleContext(0, ShowRoleGrantContext); + } + public showGrants(): ShowGrantsContext | undefined { + return this.tryGetRuleContext(0, ShowGrantsContext); + } + public showFiles(): ShowFilesContext | undefined { + return this.tryGetRuleContext(0, ShowFilesContext); + } + public showPartitions(): ShowPartitionsContext | undefined { + return this.tryGetRuleContext(0, ShowPartitionsContext); + } + public showColumnStats(): ShowColumnStatsContext | undefined { + return this.tryGetRuleContext(0, ShowColumnStatsContext); + } + public showTableStats(): ShowTableStatsContext | undefined { + return this.tryGetRuleContext(0, ShowTableStatsContext); + } + public showCreateView(): ShowCreateViewContext | undefined { + return this.tryGetRuleContext(0, ShowCreateViewContext); + } + public showCreateTable(): ShowCreateTableContext | undefined { + return this.tryGetRuleContext(0, ShowCreateTableContext); + } + public showFunctions(): ShowFunctionsContext | undefined { + return this.tryGetRuleContext(0, ShowFunctionsContext); + } + public showTables(): ShowTablesContext | undefined { + return this.tryGetRuleContext(0, ShowTablesContext); + } + public showSchemas(): ShowSchemasContext | undefined { + return this.tryGetRuleContext(0, ShowSchemasContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowStatement) { + listener.enterShowStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowStatement) { + listener.exitShowStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowStatement) { + return visitor.visitShowStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowSchemasContext extends ParserRuleContext { + public _pattern!: StringLiteralContext; + public KW_SHOW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_SCHEMAS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SCHEMAS, 0); } + public KW_DATABASES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DATABASES, 0); } + public stringLiteral(): StringLiteralContext[]; + public stringLiteral(i: number): StringLiteralContext; + public stringLiteral(i?: number): StringLiteralContext | StringLiteralContext[] { + if (i === undefined) { + return this.getRuleContexts(StringLiteralContext); + } else { + return this.getRuleContext(i, StringLiteralContext); + } + } + public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LIKE, 0); } + public BITWISEOR(): TerminalNode[]; + public BITWISEOR(i: number): TerminalNode; + public BITWISEOR(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.BITWISEOR); + } else { + return this.getToken(ImpalaSqlParser.BITWISEOR, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showSchemas; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowSchemas) { + listener.enterShowSchemas(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowSchemas) { + listener.exitShowSchemas(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowSchemas) { + return visitor.visitShowSchemas(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowTablesContext extends ParserRuleContext { + public _pattern!: StringLiteralContext; + public KW_SHOW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_TABLES(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLES, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_IN, 0); } + public tableNamePath(): TableNamePathContext | undefined { + return this.tryGetRuleContext(0, TableNamePathContext); + } + public stringLiteral(): StringLiteralContext[]; + public stringLiteral(i: number): StringLiteralContext; + public stringLiteral(i?: number): StringLiteralContext | StringLiteralContext[] { + if (i === undefined) { + return this.getRuleContexts(StringLiteralContext); + } else { + return this.getRuleContext(i, StringLiteralContext); + } + } + public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LIKE, 0); } + public BITWISEOR(): TerminalNode[]; + public BITWISEOR(i: number): TerminalNode; + public BITWISEOR(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.BITWISEOR); + } else { + return this.getToken(ImpalaSqlParser.BITWISEOR, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showTables; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowTables) { + listener.enterShowTables(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowTables) { + listener.exitShowTables(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowTables) { + return visitor.visitShowTables(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowFunctionsContext extends ParserRuleContext { + public _pattern!: StringLiteralContext; + public KW_SHOW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_FUNCTIONS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_FUNCTIONS, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_IN, 0); } + public databaseNamePath(): DatabaseNamePathContext | undefined { + return this.tryGetRuleContext(0, DatabaseNamePathContext); + } + public KW_AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_AGGREGATE, 0); } + public KW_ANALYTIC(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ANALYTIC, 0); } + public stringLiteral(): StringLiteralContext[]; + public stringLiteral(i: number): StringLiteralContext; + public stringLiteral(i?: number): StringLiteralContext | StringLiteralContext[] { + if (i === undefined) { + return this.getRuleContexts(StringLiteralContext); + } else { + return this.getRuleContext(i, StringLiteralContext); + } + } + public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LIKE, 0); } + public BITWISEOR(): TerminalNode[]; + public BITWISEOR(i: number): TerminalNode; + public BITWISEOR(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.BITWISEOR); + } else { + return this.getToken(ImpalaSqlParser.BITWISEOR, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showFunctions; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowFunctions) { + listener.enterShowFunctions(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowFunctions) { + listener.exitShowFunctions(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowFunctions) { + return visitor.visitShowFunctions(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowCreateTableContext extends ParserRuleContext { + public KW_SHOW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CREATE, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showCreateTable; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowCreateTable) { + listener.enterShowCreateTable(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowCreateTable) { + listener.exitShowCreateTable(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowCreateTable) { + return visitor.visitShowCreateTable(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowCreateViewContext extends ParserRuleContext { + public KW_SHOW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CREATE, 0); } + public KW_VIEW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_VIEW, 0); } + public viewNamePath(): ViewNamePathContext { + return this.getRuleContext(0, ViewNamePathContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showCreateView; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowCreateView) { + listener.enterShowCreateView(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowCreateView) { + listener.exitShowCreateView(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowCreateView) { + return visitor.visitShowCreateView(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowTableStatsContext extends ParserRuleContext { + public KW_SHOW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public KW_STATS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_STATS, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showTableStats; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowTableStats) { + listener.enterShowTableStats(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowTableStats) { + listener.exitShowTableStats(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowTableStats) { + return visitor.visitShowTableStats(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowColumnStatsContext extends ParserRuleContext { + public KW_SHOW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_COLUMN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_COLUMN, 0); } + public KW_STATS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_STATS, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showColumnStats; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowColumnStats) { + listener.enterShowColumnStats(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowColumnStats) { + listener.exitShowColumnStats(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowColumnStats) { + return visitor.visitShowColumnStats(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowPartitionsContext extends ParserRuleContext { + public KW_SHOW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_PARTITIONS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_PARTITIONS, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_RANGE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RANGE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showPartitions; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowPartitions) { + listener.enterShowPartitions(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowPartitions) { + listener.exitShowPartitions(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowPartitions) { + return visitor.visitShowPartitions(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowFilesContext extends ParserRuleContext { + public KW_SHOW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_FILES(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_FILES, 0); } + public KW_IN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_IN, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITION, 0); } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public COMMA(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.COMMA, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showFiles; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowFiles) { + listener.enterShowFiles(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowFiles) { + listener.exitShowFiles(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowFiles) { + return visitor.visitShowFiles(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowRolesContext extends ParserRuleContext { + public KW_SHOW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_ROLES(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ROLES, 0); } + public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_CURRENT, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showRoles; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowRoles) { + listener.enterShowRoles(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowRoles) { + listener.exitShowRoles(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowRoles) { + return visitor.visitShowRoles(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowRoleGrantContext extends ParserRuleContext { + public KW_SHOW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_ROLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ROLE, 0); } + public KW_GRANT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_GRANT, 0); } + public KW_GROUP(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_GROUP, 0); } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showRoleGrant; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowRoleGrant) { + listener.enterShowRoleGrant(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowRoleGrant) { + listener.exitShowRoleGrant(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowRoleGrant) { + return visitor.visitShowRoleGrant(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowGrantsContext extends ParserRuleContext { + public showDatabaseGrant(): ShowDatabaseGrantContext | undefined { + return this.tryGetRuleContext(0, ShowDatabaseGrantContext); + } + public showTableGrant(): ShowTableGrantContext | undefined { + return this.tryGetRuleContext(0, ShowTableGrantContext); + } + public showColumnGrant(): ShowColumnGrantContext | undefined { + return this.tryGetRuleContext(0, ShowColumnGrantContext); + } + public KW_SHOW(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_GRANT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_GRANT, 0); } + public identifier(): IdentifierContext | undefined { + return this.tryGetRuleContext(0, IdentifierContext); + } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_USER, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROLE, 0); } + public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_GROUP, 0); } + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ON, 0); } + public KW_SERVER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SERVER, 0); } + public KW_URI(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_URI, 0); } + public qualifiedName(): QualifiedNameContext | undefined { + return this.tryGetRuleContext(0, QualifiedNameContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showGrants; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowGrants) { + listener.enterShowGrants(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowGrants) { + listener.exitShowGrants(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowGrants) { + return visitor.visitShowGrants(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowDatabaseGrantContext extends ParserRuleContext { + public KW_SHOW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_GRANT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_GRANT, 0); } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_USER, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROLE, 0); } + public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_GROUP, 0); } + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ON, 0); } + public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DATABASE, 0); } + public databaseNamePath(): DatabaseNamePathContext | undefined { + return this.tryGetRuleContext(0, DatabaseNamePathContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showDatabaseGrant; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowDatabaseGrant) { + listener.enterShowDatabaseGrant(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowDatabaseGrant) { + listener.exitShowDatabaseGrant(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowDatabaseGrant) { + return visitor.visitShowDatabaseGrant(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowTableGrantContext extends ParserRuleContext { + public KW_SHOW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_GRANT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_GRANT, 0); } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_USER, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROLE, 0); } + public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_GROUP, 0); } + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ON, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext | undefined { + return this.tryGetRuleContext(0, TableNamePathContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showTableGrant; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowTableGrant) { + listener.enterShowTableGrant(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowTableGrant) { + listener.exitShowTableGrant(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowTableGrant) { + return visitor.visitShowTableGrant(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShowColumnGrantContext extends ParserRuleContext { + public KW_SHOW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_GRANT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_GRANT, 0); } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_USER, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROLE, 0); } + public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_GROUP, 0); } + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ON, 0); } + public KW_COLUMN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COLUMN, 0); } + public columnNamePath(): ColumnNamePathContext | undefined { + return this.tryGetRuleContext(0, ColumnNamePathContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_showColumnGrant; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShowColumnGrant) { + listener.enterShowColumnGrant(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShowColumnGrant) { + listener.exitShowColumnGrant(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShowColumnGrant) { + return visitor.visitShowColumnGrant(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AddCommentStatementContext extends ParserRuleContext { + public addDatabaseComments(): AddDatabaseCommentsContext | undefined { + return this.tryGetRuleContext(0, AddDatabaseCommentsContext); + } + public addTableComments(): AddTableCommentsContext | undefined { + return this.tryGetRuleContext(0, AddTableCommentsContext); + } + public addColumnComments(): AddColumnCommentsContext | undefined { + return this.tryGetRuleContext(0, AddColumnCommentsContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_addCommentStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAddCommentStatement) { + listener.enterAddCommentStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAddCommentStatement) { + listener.exitAddCommentStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAddCommentStatement) { + return visitor.visitAddCommentStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AddDatabaseCommentsContext extends ParserRuleContext { + public KW_COMMENT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_COMMENT, 0); } + public KW_ON(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ON, 0); } + public KW_DATABASE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DATABASE, 0); } + public databaseNamePath(): DatabaseNamePathContext { + return this.getRuleContext(0, DatabaseNamePathContext); + } + public KW_IS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_IS, 0); } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NULL, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_addDatabaseComments; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAddDatabaseComments) { + listener.enterAddDatabaseComments(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAddDatabaseComments) { + listener.exitAddDatabaseComments(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAddDatabaseComments) { + return visitor.visitAddDatabaseComments(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AddTableCommentsContext extends ParserRuleContext { + public KW_COMMENT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_COMMENT, 0); } + public KW_ON(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ON, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_IS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_IS, 0); } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NULL, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_addTableComments; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAddTableComments) { + listener.enterAddTableComments(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAddTableComments) { + listener.exitAddTableComments(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAddTableComments) { + return visitor.visitAddTableComments(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AddColumnCommentsContext extends ParserRuleContext { + public KW_COMMENT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_COMMENT, 0); } + public KW_ON(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ON, 0); } + public KW_COLUMN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_COLUMN, 0); } + public columnNamePath(): ColumnNamePathContext { + return this.getRuleContext(0, ColumnNamePathContext); + } + public KW_IS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_IS, 0); } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NULL, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_addColumnComments; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAddColumnComments) { + listener.enterAddColumnComments(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAddColumnComments) { + listener.exitAddColumnComments(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAddColumnComments) { + return visitor.visitAddColumnComments(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ExplainStatementContext extends ParserRuleContext { + public KW_EXPLAIN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_EXPLAIN, 0); } + public statement(): StatementContext { + return this.getRuleContext(0, StatementContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_explainStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterExplainStatement) { + listener.enterExplainStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitExplainStatement) { + listener.exitExplainStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitExplainStatement) { + return visitor.visitExplainStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SetStatementContext extends ParserRuleContext { + public KW_SET(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SET, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ALL, 0); } + public identifier(): IdentifierContext | undefined { + return this.tryGetRuleContext(0, IdentifierContext); + } + public EQ(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.EQ, 0); } + public expression(): ExpressionContext | undefined { + return this.tryGetRuleContext(0, ExpressionContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_setStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSetStatement) { + listener.enterSetStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSetStatement) { + listener.exitSetStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSetStatement) { + return visitor.visitSetStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ShutdownStatementContext extends ParserRuleContext { + public COLON(): TerminalNode { return this.getToken(ImpalaSqlParser.COLON, 0); } + public KW_SHUTDOWN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SHUTDOWN, 0); } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + public expression(): ExpressionContext | undefined { + return this.tryGetRuleContext(0, ExpressionContext); + } + public COMMA(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.COMMA, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_shutdownStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterShutdownStatement) { + listener.enterShutdownStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitShutdownStatement) { + listener.exitShutdownStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitShutdownStatement) { + return visitor.visitShutdownStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class InvalidateMetaStatementContext extends ParserRuleContext { + public KW_INVALIDATE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_INVALIDATE, 0); } + public KW_METADATA(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_METADATA, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_invalidateMetaStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterInvalidateMetaStatement) { + listener.enterInvalidateMetaStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitInvalidateMetaStatement) { + listener.exitInvalidateMetaStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitInvalidateMetaStatement) { + return visitor.visitInvalidateMetaStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class LoadDataStatementContext extends ParserRuleContext { + public KW_LOAD(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_LOAD, 0); } + public KW_DATA(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DATA, 0); } + public KW_INPATH(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_INPATH, 0); } + public STRING(): TerminalNode { return this.getToken(ImpalaSqlParser.STRING, 0); } + public KW_INTO(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_INTO, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_OVERWRITE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_OVERWRITE, 0); } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITION, 0); } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public COMMA(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.COMMA, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_loadDataStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterLoadDataStatement) { + listener.enterLoadDataStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitLoadDataStatement) { + listener.exitLoadDataStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitLoadDataStatement) { + return visitor.visitLoadDataStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RefreshStatementContext extends ParserRuleContext { + public refreshMeta(): RefreshMetaContext | undefined { + return this.tryGetRuleContext(0, RefreshMetaContext); + } + public refreshAuth(): RefreshAuthContext | undefined { + return this.tryGetRuleContext(0, RefreshAuthContext); + } + public refreshFunction(): RefreshFunctionContext | undefined { + return this.tryGetRuleContext(0, RefreshFunctionContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_refreshStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRefreshStatement) { + listener.enterRefreshStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRefreshStatement) { + listener.exitRefreshStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRefreshStatement) { + return visitor.visitRefreshStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RefreshMetaContext extends ParserRuleContext { + public KW_REFRESH(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_REFRESH, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITION, 0); } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_refreshMeta; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRefreshMeta) { + listener.enterRefreshMeta(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRefreshMeta) { + listener.exitRefreshMeta(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRefreshMeta) { + return visitor.visitRefreshMeta(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RefreshAuthContext extends ParserRuleContext { + public KW_REFRESH(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_REFRESH, 0); } + public KW_AUTHORIZATION(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_AUTHORIZATION, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_refreshAuth; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRefreshAuth) { + listener.enterRefreshAuth(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRefreshAuth) { + listener.exitRefreshAuth(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRefreshAuth) { + return visitor.visitRefreshAuth(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RefreshFunctionContext extends ParserRuleContext { + public KW_REFRESH(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_REFRESH, 0); } + public KW_FUNCTIONS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_FUNCTIONS, 0); } + public functionNamePath(): FunctionNamePathContext { + return this.getRuleContext(0, FunctionNamePathContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_refreshFunction; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRefreshFunction) { + listener.enterRefreshFunction(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRefreshFunction) { + listener.exitRefreshFunction(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRefreshFunction) { + return visitor.visitRefreshFunction(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IfExistsContext extends ParserRuleContext { + public KW_IF(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_EXISTS, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_ifExists; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterIfExists) { + listener.enterIfExists(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitIfExists) { + listener.exitIfExists(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitIfExists) { + return visitor.visitIfExists(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IfNotExistsContext extends ParserRuleContext { + public KW_IF(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_IF, 0); } + public KW_NOT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_EXISTS, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_ifNotExists; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterIfNotExists) { + listener.enterIfNotExists(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitIfNotExists) { + listener.exitIfNotExists(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitIfNotExists) { + return visitor.visitIfNotExists(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TableNameCreateContext extends ParserRuleContext { + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_tableNameCreate; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterTableNameCreate) { + listener.enterTableNameCreate(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitTableNameCreate) { + listener.exitTableNameCreate(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitTableNameCreate) { + return visitor.visitTableNameCreate(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DatabaseNameCreateContext extends ParserRuleContext { + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_databaseNameCreate; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDatabaseNameCreate) { + listener.enterDatabaseNameCreate(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDatabaseNameCreate) { + listener.exitDatabaseNameCreate(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDatabaseNameCreate) { + return visitor.visitDatabaseNameCreate(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ViewNameCreateContext extends ParserRuleContext { + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_viewNameCreate; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterViewNameCreate) { + listener.enterViewNameCreate(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitViewNameCreate) { + listener.exitViewNameCreate(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitViewNameCreate) { + return visitor.visitViewNameCreate(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FunctionNameCreateContext extends ParserRuleContext { + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_functionNameCreate; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterFunctionNameCreate) { + listener.enterFunctionNameCreate(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitFunctionNameCreate) { + listener.exitFunctionNameCreate(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitFunctionNameCreate) { + return visitor.visitFunctionNameCreate(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ColumnNamePathCreateContext extends ParserRuleContext { + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_columnNamePathCreate; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterColumnNamePathCreate) { + listener.enterColumnNamePathCreate(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitColumnNamePathCreate) { + listener.exitColumnNamePathCreate(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitColumnNamePathCreate) { + return visitor.visitColumnNamePathCreate(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DatabaseNamePathContext extends ParserRuleContext { + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_databaseNamePath; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDatabaseNamePath) { + listener.enterDatabaseNamePath(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDatabaseNamePath) { + listener.exitDatabaseNamePath(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDatabaseNamePath) { + return visitor.visitDatabaseNamePath(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TableNamePathContext extends ParserRuleContext { + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext; + public identifier(i?: number): IdentifierContext | IdentifierContext[] { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } else { + return this.getRuleContext(i, IdentifierContext); + } + } + public DOT(): TerminalNode[]; + public DOT(i: number): TerminalNode; + public DOT(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.DOT); + } else { + return this.getToken(ImpalaSqlParser.DOT, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_tableNamePath; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterTableNamePath) { + listener.enterTableNamePath(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitTableNamePath) { + listener.exitTableNamePath(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitTableNamePath) { + return visitor.visitTableNamePath(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ViewNamePathContext extends ParserRuleContext { + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext; + public identifier(i?: number): IdentifierContext | IdentifierContext[] { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } else { + return this.getRuleContext(i, IdentifierContext); + } + } + public DOT(): TerminalNode[]; + public DOT(i: number): TerminalNode; + public DOT(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.DOT); + } else { + return this.getToken(ImpalaSqlParser.DOT, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_viewNamePath; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterViewNamePath) { + listener.enterViewNamePath(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitViewNamePath) { + listener.exitViewNamePath(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitViewNamePath) { + return visitor.visitViewNamePath(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FunctionNamePathContext extends ParserRuleContext { + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_functionNamePath; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterFunctionNamePath) { + listener.enterFunctionNamePath(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitFunctionNamePath) { + listener.exitFunctionNamePath(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitFunctionNamePath) { + return visitor.visitFunctionNamePath(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ColumnNamePathContext extends ParserRuleContext { + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_columnNamePath; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterColumnNamePath) { + listener.enterColumnNamePath(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitColumnNamePath) { + listener.exitColumnNamePath(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitColumnNamePath) { + return visitor.visitColumnNamePath(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TableOrViewPathContext extends ParserRuleContext { + public tableNamePath(): TableNamePathContext | undefined { + return this.tryGetRuleContext(0, TableNamePathContext); + } + public viewNamePath(): ViewNamePathContext | undefined { + return this.tryGetRuleContext(0, ViewNamePathContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_tableOrViewPath; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterTableOrViewPath) { + listener.enterTableOrViewPath(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitTableOrViewPath) { + listener.exitTableOrViewPath(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitTableOrViewPath) { + return visitor.visitTableOrViewPath(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateCommonItemContext extends ParserRuleContext { + public _comment!: StringLiteralContext; + public _serdProp!: PropertiesContext; + public _location!: StringLiteralContext; + public _cacheName!: QualifiedNameContext; + public _tblProp!: PropertiesContext; + public KW_SORT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SORT, 0); } + public KW_BY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_BY, 0); } + public columnAliases(): ColumnAliasesContext | undefined { + return this.tryGetRuleContext(0, ColumnAliasesContext); + } + public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COMMENT, 0); } + public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROW, 0); } + public KW_FORMAT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FORMAT, 0); } + public rowFormat(): RowFormatContext | undefined { + return this.tryGetRuleContext(0, RowFormatContext); + } + public KW_WITH(): TerminalNode[]; + public KW_WITH(i: number): TerminalNode; + public KW_WITH(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.KW_WITH); + } else { + return this.getToken(ImpalaSqlParser.KW_WITH, i); + } + } + public KW_SERDEPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SERDEPROPERTIES, 0); } + public KW_STORED(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_STORED, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_AS, 0); } + public fileFormat(): FileFormatContext | undefined { + return this.tryGetRuleContext(0, FileFormatContext); + } + public KW_LOCATION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LOCATION, 0); } + public KW_CACHED(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_CACHED, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_IN, 0); } + public KW_UNCACHED(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_UNCACHED, 0); } + public KW_TBLPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TBLPROPERTIES, 0); } + public stringLiteral(): StringLiteralContext[]; + public stringLiteral(i: number): StringLiteralContext; + public stringLiteral(i?: number): StringLiteralContext | StringLiteralContext[] { + if (i === undefined) { + return this.getRuleContexts(StringLiteralContext); + } else { + return this.getRuleContext(i, StringLiteralContext); + } + } + public properties(): PropertiesContext[]; + public properties(i: number): PropertiesContext; + public properties(i?: number): PropertiesContext | PropertiesContext[] { + if (i === undefined) { + return this.getRuleContexts(PropertiesContext); + } else { + return this.getRuleContext(i, PropertiesContext); + } + } + public qualifiedName(): QualifiedNameContext | undefined { + return this.tryGetRuleContext(0, QualifiedNameContext); + } + public KW_REPLICATION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_REPLICATION, 0); } + public EQ(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.EQ, 0); } + public INTEGER_VALUE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.INTEGER_VALUE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_createCommonItem; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCreateCommonItem) { + listener.enterCreateCommonItem(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCreateCommonItem) { + listener.exitCreateCommonItem(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCreateCommonItem) { + return visitor.visitCreateCommonItem(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AssignmentListContext extends ParserRuleContext { + public assignmentItem(): AssignmentItemContext[]; + public assignmentItem(i: number): AssignmentItemContext; + public assignmentItem(i?: number): AssignmentItemContext | AssignmentItemContext[] { + if (i === undefined) { + return this.getRuleContexts(AssignmentItemContext); + } else { + return this.getRuleContext(i, AssignmentItemContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_assignmentList; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAssignmentList) { + listener.enterAssignmentList(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAssignmentList) { + listener.exitAssignmentList(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAssignmentList) { + return visitor.visitAssignmentList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AssignmentItemContext extends ParserRuleContext { + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext); + } + public EQ(): TerminalNode { return this.getToken(ImpalaSqlParser.EQ, 0); } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_assignmentItem; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAssignmentItem) { + listener.enterAssignmentItem(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAssignmentItem) { + listener.exitAssignmentItem(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAssignmentItem) { + return visitor.visitAssignmentItem(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ViewColumnsContext extends ParserRuleContext { + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public columnNamePath(): ColumnNamePathContext { + return this.getRuleContext(0, ColumnNamePathContext); + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public KW_COMMENT(): TerminalNode[]; + public KW_COMMENT(i: number): TerminalNode; + public KW_COMMENT(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.KW_COMMENT); + } else { + return this.getToken(ImpalaSqlParser.KW_COMMENT, i); + } + } + public stringLiteral(): StringLiteralContext[]; + public stringLiteral(i: number): StringLiteralContext; + public stringLiteral(i?: number): StringLiteralContext | StringLiteralContext[] { + if (i === undefined) { + return this.getRuleContexts(StringLiteralContext); + } else { + return this.getRuleContext(i, StringLiteralContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext; + public identifier(i?: number): IdentifierContext | IdentifierContext[] { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } else { + return this.getRuleContext(i, IdentifierContext); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_viewColumns; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterViewColumns) { + listener.enterViewColumns(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitViewColumns) { + listener.exitViewColumns(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitViewColumns) { + return visitor.visitViewColumns(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QueryStatementContext extends ParserRuleContext { + public queryNoWith(): QueryNoWithContext { + return this.getRuleContext(0, QueryNoWithContext); + } + public with(): WithContext | undefined { + return this.tryGetRuleContext(0, WithContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_queryStatement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterQueryStatement) { + listener.enterQueryStatement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitQueryStatement) { + listener.exitQueryStatement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitQueryStatement) { + return visitor.visitQueryStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WithContext extends ParserRuleContext { + public KW_WITH(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_WITH, 0); } + public namedQuery(): NamedQueryContext[]; + public namedQuery(i: number): NamedQueryContext; + public namedQuery(i?: number): NamedQueryContext | NamedQueryContext[] { + if (i === undefined) { + return this.getRuleContexts(NamedQueryContext); + } else { + return this.getRuleContext(i, NamedQueryContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_with; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterWith) { + listener.enterWith(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitWith) { + listener.exitWith(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitWith) { + return visitor.visitWith(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ConstraintSpecificationContext extends ParserRuleContext { + public KW_PRIMARY(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_PRIMARY, 0); } + public KW_KEY(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_KEY, 0); } + public columnAliases(): ColumnAliasesContext { + return this.getRuleContext(0, ColumnAliasesContext); + } + public KW_DISABLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DISABLE, 0); } + public KW_NOVALIDATE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NOVALIDATE, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + public KW_RELY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RELY, 0); } + public foreignKeySpecification(): ForeignKeySpecificationContext[]; + public foreignKeySpecification(i: number): ForeignKeySpecificationContext; + public foreignKeySpecification(i?: number): ForeignKeySpecificationContext | ForeignKeySpecificationContext[] { + if (i === undefined) { + return this.getRuleContexts(ForeignKeySpecificationContext); + } else { + return this.getRuleContext(i, ForeignKeySpecificationContext); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_constraintSpecification; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterConstraintSpecification) { + listener.enterConstraintSpecification(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitConstraintSpecification) { + listener.exitConstraintSpecification(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitConstraintSpecification) { + return visitor.visitConstraintSpecification(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ForeignKeySpecificationContext extends ParserRuleContext { + public KW_FOREIGN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_FOREIGN, 0); } + public KW_KEY(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_KEY, 0); } + public columnAliases(): ColumnAliasesContext[]; + public columnAliases(i: number): ColumnAliasesContext; + public columnAliases(i?: number): ColumnAliasesContext | ColumnAliasesContext[] { + if (i === undefined) { + return this.getRuleContexts(ColumnAliasesContext); + } else { + return this.getRuleContext(i, ColumnAliasesContext); + } + } + public KW_REFERENCES(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_REFERENCES, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + public KW_DISABLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DISABLE, 0); } + public KW_NOVALIDATE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NOVALIDATE, 0); } + public KW_RELY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RELY, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_foreignKeySpecification; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterForeignKeySpecification) { + listener.enterForeignKeySpecification(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitForeignKeySpecification) { + listener.exitForeignKeySpecification(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitForeignKeySpecification) { + return visitor.visitForeignKeySpecification(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ColumnDefinitionContext extends ParserRuleContext { + public columnNamePathCreate(): ColumnNamePathCreateContext { + return this.getRuleContext(0, ColumnNamePathCreateContext); + } + public type(): TypeContext { + return this.getRuleContext(0, TypeContext); + } + public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COMMENT, 0); } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_columnDefinition; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterColumnDefinition) { + listener.enterColumnDefinition(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitColumnDefinition) { + listener.exitColumnDefinition(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitColumnDefinition) { + return visitor.visitColumnDefinition(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class KuduTableElementContext extends ParserRuleContext { + public kuduColumnDefinition(): KuduColumnDefinitionContext { + return this.getRuleContext(0, KuduColumnDefinitionContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_kuduTableElement; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterKuduTableElement) { + listener.enterKuduTableElement(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitKuduTableElement) { + listener.exitKuduTableElement(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitKuduTableElement) { + return visitor.visitKuduTableElement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class KuduColumnDefinitionContext extends ParserRuleContext { + public columnNamePathCreate(): ColumnNamePathCreateContext { + return this.getRuleContext(0, ColumnNamePathCreateContext); + } + public type(): TypeContext { + return this.getRuleContext(0, TypeContext); + } + public kuduAttributes(): KuduAttributesContext[]; + public kuduAttributes(i: number): KuduAttributesContext; + public kuduAttributes(i?: number): KuduAttributesContext | KuduAttributesContext[] { + if (i === undefined) { + return this.getRuleContexts(KuduAttributesContext); + } else { + return this.getRuleContext(i, KuduAttributesContext); + } + } + public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COMMENT, 0); } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + public KW_PRIMARY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PRIMARY, 0); } + public KW_KEY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_KEY, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_kuduColumnDefinition; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterKuduColumnDefinition) { + listener.enterKuduColumnDefinition(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitKuduColumnDefinition) { + listener.exitKuduColumnDefinition(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitKuduColumnDefinition) { + return visitor.visitKuduColumnDefinition(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ColumnSpecWithKuduContext extends ParserRuleContext { + public columnNamePath(): ColumnNamePathContext { + return this.getRuleContext(0, ColumnNamePathContext); + } + public type(): TypeContext { + return this.getRuleContext(0, TypeContext); + } + public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COMMENT, 0); } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + public kuduAttributes(): KuduAttributesContext[]; + public kuduAttributes(i: number): KuduAttributesContext; + public kuduAttributes(i?: number): KuduAttributesContext | KuduAttributesContext[] { + if (i === undefined) { + return this.getRuleContexts(KuduAttributesContext); + } else { + return this.getRuleContext(i, KuduAttributesContext); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_columnSpecWithKudu; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterColumnSpecWithKudu) { + listener.enterColumnSpecWithKudu(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitColumnSpecWithKudu) { + listener.exitColumnSpecWithKudu(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitColumnSpecWithKudu) { + return visitor.visitColumnSpecWithKudu(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateColumnSpecWithKuduContext extends ParserRuleContext { + public columnNamePathCreate(): ColumnNamePathCreateContext { + return this.getRuleContext(0, ColumnNamePathCreateContext); + } + public type(): TypeContext { + return this.getRuleContext(0, TypeContext); + } + public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COMMENT, 0); } + public stringLiteral(): StringLiteralContext | undefined { + return this.tryGetRuleContext(0, StringLiteralContext); + } + public kuduAttributes(): KuduAttributesContext[]; + public kuduAttributes(i: number): KuduAttributesContext; + public kuduAttributes(i?: number): KuduAttributesContext | KuduAttributesContext[] { + if (i === undefined) { + return this.getRuleContexts(KuduAttributesContext); + } else { + return this.getRuleContext(i, KuduAttributesContext); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_createColumnSpecWithKudu; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCreateColumnSpecWithKudu) { + listener.enterCreateColumnSpecWithKudu(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCreateColumnSpecWithKudu) { + listener.exitCreateColumnSpecWithKudu(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCreateColumnSpecWithKudu) { + return visitor.visitCreateColumnSpecWithKudu(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class KuduAttributesContext extends ParserRuleContext { + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NULL, 0); } + public kuduStorageAttr(): KuduStorageAttrContext | undefined { + return this.tryGetRuleContext(0, KuduStorageAttrContext); + } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NOT, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_kuduAttributes; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterKuduAttributes) { + listener.enterKuduAttributes(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitKuduAttributes) { + listener.exitKuduAttributes(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitKuduAttributes) { + return visitor.visitKuduAttributes(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class KuduStorageAttrContext extends ParserRuleContext { + public KW_ENCODING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ENCODING, 0); } + public expression(): ExpressionContext | undefined { + return this.tryGetRuleContext(0, ExpressionContext); + } + public KW_COMPRESSION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COMPRESSION, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DEFAULT, 0); } + public KW_BLOCK_SIZE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_BLOCK_SIZE, 0); } + public number(): NumberContext | undefined { + return this.tryGetRuleContext(0, NumberContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_kuduStorageAttr; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterKuduStorageAttr) { + listener.enterKuduStorageAttr(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitKuduStorageAttr) { + listener.exitKuduStorageAttr(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitKuduStorageAttr) { + return visitor.visitKuduStorageAttr(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class StatsKeyContext extends ParserRuleContext { + public STATS_NUMDVS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.STATS_NUMDVS, 0); } + public STATS_NUMNULLS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.STATS_NUMNULLS, 0); } + public STATS_AVGSIZE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.STATS_AVGSIZE, 0); } + public STATS_MAXSIZE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.STATS_MAXSIZE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_statsKey; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterStatsKey) { + listener.enterStatsKey(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitStatsKey) { + listener.exitStatsKey(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitStatsKey) { + return visitor.visitStatsKey(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FileFormatContext extends ParserRuleContext { + public KW_TEXTFILE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TEXTFILE, 0); } + public KW_PARQUET(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARQUET, 0); } + public KW_ORC(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ORC, 0); } + public KW_AVRO(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_AVRO, 0); } + public KW_SEQUENCEFILE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SEQUENCEFILE, 0); } + public KW_RCFILE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RCFILE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_fileFormat; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterFileFormat) { + listener.enterFileFormat(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitFileFormat) { + listener.exitFileFormat(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitFileFormat) { + return visitor.visitFileFormat(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class KuduPartitionClauseContext extends ParserRuleContext { + public hashClause(): HashClauseContext[]; + public hashClause(i: number): HashClauseContext; + public hashClause(i?: number): HashClauseContext | HashClauseContext[] { + if (i === undefined) { + return this.getRuleContexts(HashClauseContext); + } else { + return this.getRuleContext(i, HashClauseContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + public rangeClause(): RangeClauseContext | undefined { + return this.tryGetRuleContext(0, RangeClauseContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_kuduPartitionClause; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterKuduPartitionClause) { + listener.enterKuduPartitionClause(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitKuduPartitionClause) { + listener.exitKuduPartitionClause(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitKuduPartitionClause) { + return visitor.visitKuduPartitionClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class HashClauseContext extends ParserRuleContext { + public KW_HASH(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_HASH, 0); } + public KW_PARTITIONS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_PARTITIONS, 0); } + public number(): NumberContext { + return this.getRuleContext(0, NumberContext); + } + public columnAliases(): ColumnAliasesContext | undefined { + return this.tryGetRuleContext(0, ColumnAliasesContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_hashClause; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterHashClause) { + listener.enterHashClause(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitHashClause) { + listener.exitHashClause(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitHashClause) { + return visitor.visitHashClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RangeClauseContext extends ParserRuleContext { + public KW_RANGE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_RANGE, 0); } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public KW_PARTITION(): TerminalNode[]; + public KW_PARTITION(i: number): TerminalNode; + public KW_PARTITION(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.KW_PARTITION); + } else { + return this.getToken(ImpalaSqlParser.KW_PARTITION, i); + } + } + public kuduPartitionSpec(): KuduPartitionSpecContext[]; + public kuduPartitionSpec(i: number): KuduPartitionSpecContext; + public kuduPartitionSpec(i?: number): KuduPartitionSpecContext | KuduPartitionSpecContext[] { + if (i === undefined) { + return this.getRuleContexts(KuduPartitionSpecContext); + } else { + return this.getRuleContext(i, KuduPartitionSpecContext); + } + } + public columnAliases(): ColumnAliasesContext | undefined { + return this.tryGetRuleContext(0, ColumnAliasesContext); + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_rangeClause; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRangeClause) { + listener.enterRangeClause(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRangeClause) { + listener.exitRangeClause(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRangeClause) { + return visitor.visitRangeClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class KuduPartitionSpecContext extends ParserRuleContext { + public KW_VALUE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_VALUE, 0); } + public partitionCol(): PartitionColContext | undefined { + return this.tryGetRuleContext(0, PartitionColContext); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + public KW_VALUES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_VALUES, 0); } + public rangeOperator(): RangeOperatorContext[]; + public rangeOperator(i: number): RangeOperatorContext; + public rangeOperator(i?: number): RangeOperatorContext | RangeOperatorContext[] { + if (i === undefined) { + return this.getRuleContexts(RangeOperatorContext); + } else { + return this.getRuleContext(i, RangeOperatorContext); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_kuduPartitionSpec; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterKuduPartitionSpec) { + listener.enterKuduPartitionSpec(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitKuduPartitionSpec) { + listener.exitKuduPartitionSpec(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitKuduPartitionSpec) { + return visitor.visitKuduPartitionSpec(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CacheSpecContext extends ParserRuleContext { + public KW_CACHED(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_CACHED, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_IN, 0); } + public identifier(): IdentifierContext | undefined { + return this.tryGetRuleContext(0, IdentifierContext); + } + public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_WITH, 0); } + public KW_REPLICATION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_REPLICATION, 0); } + public EQ(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.EQ, 0); } + public number(): NumberContext | undefined { + return this.tryGetRuleContext(0, NumberContext); + } + public KW_UNCACHED(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_UNCACHED, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_cacheSpec; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCacheSpec) { + listener.enterCacheSpec(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCacheSpec) { + listener.exitCacheSpec(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCacheSpec) { + return visitor.visitCacheSpec(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RangeOperatorContext extends ParserRuleContext { + public LT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LT, 0); } + public LTE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LTE, 0); } + public GT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.GT, 0); } + public GTE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.GTE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_rangeOperator; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRangeOperator) { + listener.enterRangeOperator(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRangeOperator) { + listener.exitRangeOperator(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRangeOperator) { + return visitor.visitRangeOperator(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PartitionColContext extends ParserRuleContext { + public EQ(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.EQ, 0); } + public NEQ(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.NEQ, 0); } + public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LIKE, 0); } + public KW_RLIKE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RLIKE, 0); } + public KW_REGEXP(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_REGEXP, 0); } + public KW_BETWEEN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_BETWEEN, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_IN, 0); } + public rangeOperator(): RangeOperatorContext | undefined { + return this.tryGetRuleContext(0, RangeOperatorContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_partitionCol; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterPartitionCol) { + listener.enterPartitionCol(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitPartitionCol) { + listener.exitPartitionCol(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitPartitionCol) { + return visitor.visitPartitionCol(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class LikeClauseContext extends ParserRuleContext { + public _optionType!: Token; + public KW_LIKE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_LIKE, 0); } + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext); + } + public KW_PROPERTIES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PROPERTIES, 0); } + public KW_INCLUDING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_INCLUDING, 0); } + public KW_EXCLUDING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_EXCLUDING, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_likeClause; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterLikeClause) { + listener.enterLikeClause(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitLikeClause) { + listener.exitLikeClause(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitLikeClause) { + return visitor.visitLikeClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PropertiesContext extends ParserRuleContext { + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public property(): PropertyContext[]; + public property(i: number): PropertyContext; + public property(i?: number): PropertyContext | PropertyContext[] { + if (i === undefined) { + return this.getRuleContexts(PropertyContext); + } else { + return this.getRuleContext(i, PropertyContext); + } + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_properties; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterProperties) { + listener.enterProperties(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitProperties) { + listener.exitProperties(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitProperties) { + return visitor.visitProperties(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PartitionedByContext extends ParserRuleContext { + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public columnDefinition(): ColumnDefinitionContext[]; + public columnDefinition(i: number): ColumnDefinitionContext; + public columnDefinition(i?: number): ColumnDefinitionContext | ColumnDefinitionContext[] { + if (i === undefined) { + return this.getRuleContexts(ColumnDefinitionContext); + } else { + return this.getRuleContext(i, ColumnDefinitionContext); + } + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_partitionedBy; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterPartitionedBy) { + listener.enterPartitionedBy(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitPartitionedBy) { + listener.exitPartitionedBy(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitPartitionedBy) { + return visitor.visitPartitionedBy(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SortedByContext extends ParserRuleContext { + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_sortedBy; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSortedBy) { + listener.enterSortedBy(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSortedBy) { + listener.exitSortedBy(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSortedBy) { + return visitor.visitSortedBy(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RowFormatContext extends ParserRuleContext { + public KW_DELIMITED(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DELIMITED, 0); } + public KW_FIELDS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FIELDS, 0); } + public KW_TERMINATED(): TerminalNode[]; + public KW_TERMINATED(i: number): TerminalNode; + public KW_TERMINATED(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.KW_TERMINATED); + } else { + return this.getToken(ImpalaSqlParser.KW_TERMINATED, i); + } + } + public KW_BY(): TerminalNode[]; + public KW_BY(i: number): TerminalNode; + public KW_BY(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.KW_BY); + } else { + return this.getToken(ImpalaSqlParser.KW_BY, i); + } + } + public stringLiteral(): StringLiteralContext[]; + public stringLiteral(i: number): StringLiteralContext; + public stringLiteral(i?: number): StringLiteralContext | StringLiteralContext[] { + if (i === undefined) { + return this.getRuleContexts(StringLiteralContext); + } else { + return this.getRuleContext(i, StringLiteralContext); + } + } + public KW_LINES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LINES, 0); } + public KW_ESCAPED(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ESCAPED, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_rowFormat; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRowFormat) { + listener.enterRowFormat(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRowFormat) { + listener.exitRowFormat(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRowFormat) { + return visitor.visitRowFormat(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PropertyContext extends ParserRuleContext { + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + public EQ(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.EQ, 0); } + public expression(): ExpressionContext | undefined { + return this.tryGetRuleContext(0, ExpressionContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_property; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterProperty) { + listener.enterProperty(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitProperty) { + listener.exitProperty(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitProperty) { + return visitor.visitProperty(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QueryNoWithContext extends ParserRuleContext { + public _rows!: ExpressionContext; + public _offset!: Token; + public queryTerm(): QueryTermContext { + return this.getRuleContext(0, QueryTermContext); + } + public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ORDER, 0); } + public KW_BY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_BY, 0); } + public sortItem(): SortItemContext[]; + public sortItem(i: number): SortItemContext; + public sortItem(i?: number): SortItemContext | SortItemContext[] { + if (i === undefined) { + return this.getRuleContexts(SortItemContext); + } else { + return this.getRuleContext(i, SortItemContext); + } + } + public KW_LIMIT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LIMIT, 0); } + public expression(): ExpressionContext | undefined { + return this.tryGetRuleContext(0, ExpressionContext); + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + public KW_OFFSET(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_OFFSET, 0); } + public INTEGER_VALUE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.INTEGER_VALUE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_queryNoWith; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterQueryNoWith) { + listener.enterQueryNoWith(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitQueryNoWith) { + listener.exitQueryNoWith(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitQueryNoWith) { + return visitor.visitQueryNoWith(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QueryTermContext extends ParserRuleContext { + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_queryTerm; } + public copyFrom(ctx: QueryTermContext): void { + super.copyFrom(ctx); + } +} +export class QueryTermDefaultContext extends QueryTermContext { + public queryPrimary(): QueryPrimaryContext { + return this.getRuleContext(0, QueryPrimaryContext); + } + constructor(ctx: QueryTermContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterQueryTermDefault) { + listener.enterQueryTermDefault(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitQueryTermDefault) { + listener.exitQueryTermDefault(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitQueryTermDefault) { + return visitor.visitQueryTermDefault(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class SetOperationContext extends QueryTermContext { + public _left!: QueryTermContext; + public _operator!: Token; + public _right!: QueryTermContext; + public queryTerm(): QueryTermContext[]; + public queryTerm(i: number): QueryTermContext; + public queryTerm(i?: number): QueryTermContext | QueryTermContext[] { + if (i === undefined) { + return this.getRuleContexts(QueryTermContext); + } else { + return this.getRuleContext(i, QueryTermContext); + } + } + public KW_INTERSECT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_INTERSECT, 0); } + public setQuantifier(): SetQuantifierContext | undefined { + return this.tryGetRuleContext(0, SetQuantifierContext); + } + public KW_UNION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_UNION, 0); } + public KW_EXCEPT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_EXCEPT, 0); } + constructor(ctx: QueryTermContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSetOperation) { + listener.enterSetOperation(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSetOperation) { + listener.exitSetOperation(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSetOperation) { + return visitor.visitSetOperation(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QueryPrimaryContext extends ParserRuleContext { + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_queryPrimary; } + public copyFrom(ctx: QueryPrimaryContext): void { + super.copyFrom(ctx); + } +} +export class QueryPrimaryDefaultContext extends QueryPrimaryContext { + public querySpecification(): QuerySpecificationContext { + return this.getRuleContext(0, QuerySpecificationContext); + } + constructor(ctx: QueryPrimaryContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterQueryPrimaryDefault) { + listener.enterQueryPrimaryDefault(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitQueryPrimaryDefault) { + listener.exitQueryPrimaryDefault(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitQueryPrimaryDefault) { + return visitor.visitQueryPrimaryDefault(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class TableContext extends QueryPrimaryContext { + public KW_TABLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_TABLE, 0); } + public tableNamePath(): TableNamePathContext { + return this.getRuleContext(0, TableNamePathContext); + } + constructor(ctx: QueryPrimaryContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterTable) { + listener.enterTable(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitTable) { + listener.exitTable(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitTable) { + return visitor.visitTable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class InlineTableContext extends QueryPrimaryContext { + public KW_VALUES(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_VALUES, 0); } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(ctx: QueryPrimaryContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterInlineTable) { + listener.enterInlineTable(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitInlineTable) { + listener.exitInlineTable(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitInlineTable) { + return visitor.visitInlineTable(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class SubqueryContext extends QueryPrimaryContext { + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public queryNoWith(): QueryNoWithContext { + return this.getRuleContext(0, QueryNoWithContext); + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + constructor(ctx: QueryPrimaryContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSubquery) { + listener.enterSubquery(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSubquery) { + listener.exitSubquery(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSubquery) { + return visitor.visitSubquery(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SortItemContext extends ParserRuleContext { + public _ordering!: Token; + public _nullOrdering!: Token; + public columnItem(): ColumnItemContext { + return this.getRuleContext(0, ColumnItemContext); + } + public KW_NULLS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NULLS, 0); } + public KW_ASC(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ASC, 0); } + public KW_DESC(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DESC, 0); } + public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FIRST, 0); } + public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LAST, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_sortItem; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSortItem) { + listener.enterSortItem(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSortItem) { + listener.exitSortItem(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSortItem) { + return visitor.visitSortItem(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QuerySpecificationContext extends ParserRuleContext { + public _where!: BooleanExpressionContext; + public _having!: BooleanExpressionContext; + public KW_SELECT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SELECT, 0); } + public selectItem(): SelectItemContext[]; + public selectItem(i: number): SelectItemContext; + public selectItem(i?: number): SelectItemContext | SelectItemContext[] { + if (i === undefined) { + return this.getRuleContexts(SelectItemContext); + } else { + return this.getRuleContext(i, SelectItemContext); + } + } + public setQuantifier(): SetQuantifierContext | undefined { + return this.tryGetRuleContext(0, SetQuantifierContext); + } + public KW_STRAIGHT_JOIN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_STRAIGHT_JOIN, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FROM, 0); } + public relation(): RelationContext[]; + public relation(i: number): RelationContext; + public relation(i?: number): RelationContext | RelationContext[] { + if (i === undefined) { + return this.getRuleContexts(RelationContext); + } else { + return this.getRuleContext(i, RelationContext); + } + } + public KW_WHERE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_WHERE, 0); } + public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_GROUP, 0); } + public KW_BY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_BY, 0); } + public groupBy(): GroupByContext | undefined { + return this.tryGetRuleContext(0, GroupByContext); + } + public KW_HAVING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_HAVING, 0); } + public booleanExpression(): BooleanExpressionContext[]; + public booleanExpression(i: number): BooleanExpressionContext; + public booleanExpression(i?: number): BooleanExpressionContext | BooleanExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(BooleanExpressionContext); + } else { + return this.getRuleContext(i, BooleanExpressionContext); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_querySpecification; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterQuerySpecification) { + listener.enterQuerySpecification(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitQuerySpecification) { + listener.exitQuerySpecification(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitQuerySpecification) { + return visitor.visitQuerySpecification(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class GroupByContext extends ParserRuleContext { + public groupingElement(): GroupingElementContext[]; + public groupingElement(i: number): GroupingElementContext; + public groupingElement(i?: number): GroupingElementContext | GroupingElementContext[] { + if (i === undefined) { + return this.getRuleContexts(GroupingElementContext); + } else { + return this.getRuleContext(i, GroupingElementContext); + } + } + public setQuantifier(): SetQuantifierContext | undefined { + return this.tryGetRuleContext(0, SetQuantifierContext); + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_groupBy; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterGroupBy) { + listener.enterGroupBy(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitGroupBy) { + listener.exitGroupBy(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitGroupBy) { + return visitor.visitGroupBy(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class GroupingElementContext extends ParserRuleContext { + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_groupingElement; } + public copyFrom(ctx: GroupingElementContext): void { + super.copyFrom(ctx); + } +} +export class SingleGroupingSetContext extends GroupingElementContext { + public groupingSet(): GroupingSetContext { + return this.getRuleContext(0, GroupingSetContext); + } + constructor(ctx: GroupingElementContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSingleGroupingSet) { + listener.enterSingleGroupingSet(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSingleGroupingSet) { + listener.exitSingleGroupingSet(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSingleGroupingSet) { + return visitor.visitSingleGroupingSet(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class GroupingSetContext extends ParserRuleContext { + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public columnItem(): ColumnItemContext[]; + public columnItem(i: number): ColumnItemContext; + public columnItem(i?: number): ColumnItemContext | ColumnItemContext[] { + if (i === undefined) { + return this.getRuleContexts(ColumnItemContext); + } else { + return this.getRuleContext(i, ColumnItemContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_groupingSet; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterGroupingSet) { + listener.enterGroupingSet(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitGroupingSet) { + listener.exitGroupingSet(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitGroupingSet) { + return visitor.visitGroupingSet(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NamedQueryContext extends ParserRuleContext { + public _name!: IdentifierContext; + public KW_AS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_AS, 0); } + public subQueryRelation(): SubQueryRelationContext { + return this.getRuleContext(0, SubQueryRelationContext); + } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + public columnAliases(): ColumnAliasesContext | undefined { + return this.tryGetRuleContext(0, ColumnAliasesContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_namedQuery; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterNamedQuery) { + listener.enterNamedQuery(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitNamedQuery) { + listener.exitNamedQuery(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitNamedQuery) { + return visitor.visitNamedQuery(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SetQuantifierContext extends ParserRuleContext { + public KW_DISTINCT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DISTINCT, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ALL, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_setQuantifier; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSetQuantifier) { + listener.enterSetQuantifier(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSetQuantifier) { + listener.exitSetQuantifier(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSetQuantifier) { + return visitor.visitSetQuantifier(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SelectItemContext extends ParserRuleContext { + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_selectItem; } + public copyFrom(ctx: SelectItemContext): void { + super.copyFrom(ctx); + } +} +export class SelectSingleContext extends SelectItemContext { + public columnItem(): ColumnItemContext { + return this.getRuleContext(0, ColumnItemContext); + } + public identifier(): IdentifierContext | undefined { + return this.tryGetRuleContext(0, IdentifierContext); + } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_AS, 0); } + constructor(ctx: SelectItemContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSelectSingle) { + listener.enterSelectSingle(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSelectSingle) { + listener.exitSelectSingle(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSelectSingle) { + return visitor.visitSelectSingle(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class SelectAllContext extends SelectItemContext { + public qualifiedName(): QualifiedNameContext | undefined { + return this.tryGetRuleContext(0, QualifiedNameContext); + } + public DOT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.DOT, 0); } + public ASTERISK(): TerminalNode { return this.getToken(ImpalaSqlParser.ASTERISK, 0); } + constructor(ctx: SelectItemContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSelectAll) { + listener.enterSelectAll(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSelectAll) { + listener.exitSelectAll(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSelectAll) { + return visitor.visitSelectAll(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RelationContext extends ParserRuleContext { + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_relation; } + public copyFrom(ctx: RelationContext): void { + super.copyFrom(ctx); + } +} +export class JoinRelationContext extends RelationContext { + public _left!: RelationContext; + public _right!: SampledRelationContext; + public _rightRelation!: RelationContext; + public relation(): RelationContext[]; + public relation(i: number): RelationContext; + public relation(i?: number): RelationContext | RelationContext[] { + if (i === undefined) { + return this.getRuleContexts(RelationContext); + } else { + return this.getRuleContext(i, RelationContext); + } + } + public KW_CROSS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_CROSS, 0); } + public KW_JOIN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_JOIN, 0); } + public joinType(): JoinTypeContext | undefined { + return this.tryGetRuleContext(0, JoinTypeContext); + } + public joinCriteria(): JoinCriteriaContext | undefined { + return this.tryGetRuleContext(0, JoinCriteriaContext); + } + public sampledRelation(): SampledRelationContext | undefined { + return this.tryGetRuleContext(0, SampledRelationContext); + } + constructor(ctx: RelationContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterJoinRelation) { + listener.enterJoinRelation(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitJoinRelation) { + listener.exitJoinRelation(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitJoinRelation) { + return visitor.visitJoinRelation(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class RelationDefaultContext extends RelationContext { + public sampledRelation(): SampledRelationContext { + return this.getRuleContext(0, SampledRelationContext); + } + constructor(ctx: RelationContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRelationDefault) { + listener.enterRelationDefault(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRelationDefault) { + listener.exitRelationDefault(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRelationDefault) { + return visitor.visitRelationDefault(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class JoinTypeContext extends ParserRuleContext { + public KW_INNER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_INNER, 0); } + public KW_LEFT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LEFT, 0); } + public KW_RIGHT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RIGHT, 0); } + public KW_OUTER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_OUTER, 0); } + public KW_FULL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FULL, 0); } + public KW_SEMI(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SEMI, 0); } + public KW_ANTI(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ANTI, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_joinType; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterJoinType) { + listener.enterJoinType(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitJoinType) { + listener.exitJoinType(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitJoinType) { + return visitor.visitJoinType(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class JoinCriteriaContext extends ParserRuleContext { + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ON, 0); } + public booleanExpression(): BooleanExpressionContext | undefined { + return this.tryGetRuleContext(0, BooleanExpressionContext); + } + public KW_USING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_USING, 0); } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext; + public identifier(i?: number): IdentifierContext | IdentifierContext[] { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } else { + return this.getRuleContext(i, IdentifierContext); + } + } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_joinCriteria; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterJoinCriteria) { + listener.enterJoinCriteria(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitJoinCriteria) { + listener.exitJoinCriteria(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitJoinCriteria) { + return visitor.visitJoinCriteria(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SampledRelationContext extends ParserRuleContext { + public _percentage!: ExpressionContext; + public _seed!: ExpressionContext; + public aliasedRelation(): AliasedRelationContext { + return this.getRuleContext(0, AliasedRelationContext); + } + public KW_TABLESAMPLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TABLESAMPLE, 0); } + public sampleType(): SampleTypeContext | undefined { + return this.tryGetRuleContext(0, SampleTypeContext); + } + public LPAREN(): TerminalNode[]; + public LPAREN(i: number): TerminalNode; + public LPAREN(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.LPAREN); + } else { + return this.getToken(ImpalaSqlParser.LPAREN, i); + } + } + public RPAREN(): TerminalNode[]; + public RPAREN(i: number): TerminalNode; + public RPAREN(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.RPAREN); + } else { + return this.getToken(ImpalaSqlParser.RPAREN, i); + } + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + public KW_REPEATABLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_REPEATABLE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_sampledRelation; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSampledRelation) { + listener.enterSampledRelation(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSampledRelation) { + listener.exitSampledRelation(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSampledRelation) { + return visitor.visitSampledRelation(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SampleTypeContext extends ParserRuleContext { + public KW_BERNOULLI(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_BERNOULLI, 0); } + public KW_SYSTEM(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SYSTEM, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_sampleType; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSampleType) { + listener.enterSampleType(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSampleType) { + listener.exitSampleType(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSampleType) { + return visitor.visitSampleType(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AliasedRelationContext extends ParserRuleContext { + public relationPrimary(): RelationPrimaryContext { + return this.getRuleContext(0, RelationPrimaryContext); + } + public identifier(): IdentifierContext | undefined { + return this.tryGetRuleContext(0, IdentifierContext); + } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_AS, 0); } + public columnAliases(): ColumnAliasesContext | undefined { + return this.tryGetRuleContext(0, ColumnAliasesContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_aliasedRelation; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterAliasedRelation) { + listener.enterAliasedRelation(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitAliasedRelation) { + listener.exitAliasedRelation(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitAliasedRelation) { + return visitor.visitAliasedRelation(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ColumnAliasesContext extends ParserRuleContext { + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public columnNamePath(): ColumnNamePathContext[]; + public columnNamePath(i: number): ColumnNamePathContext; + public columnNamePath(i?: number): ColumnNamePathContext | ColumnNamePathContext[] { + if (i === undefined) { + return this.getRuleContexts(ColumnNamePathContext); + } else { + return this.getRuleContext(i, ColumnNamePathContext); + } + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_columnAliases; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterColumnAliases) { + listener.enterColumnAliases(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitColumnAliases) { + listener.exitColumnAliases(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitColumnAliases) { + return visitor.visitColumnAliases(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreateColumnAliasesContext extends ParserRuleContext { + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public columnNamePath(): ColumnNamePathContext[]; + public columnNamePath(i: number): ColumnNamePathContext; + public columnNamePath(i?: number): ColumnNamePathContext | ColumnNamePathContext[] { + if (i === undefined) { + return this.getRuleContexts(ColumnNamePathContext); + } else { + return this.getRuleContext(i, ColumnNamePathContext); + } + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_createColumnAliases; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCreateColumnAliases) { + listener.enterCreateColumnAliases(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCreateColumnAliases) { + listener.exitCreateColumnAliases(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCreateColumnAliases) { + return visitor.visitCreateColumnAliases(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RelationPrimaryContext extends ParserRuleContext { + public tableOrViewPath(): TableOrViewPathContext | undefined { + return this.tryGetRuleContext(0, TableOrViewPathContext); + } + public subQueryRelation(): SubQueryRelationContext | undefined { + return this.tryGetRuleContext(0, SubQueryRelationContext); + } + public KW_LATERAL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LATERAL, 0); } + public unnest(): UnnestContext | undefined { + return this.tryGetRuleContext(0, UnnestContext); + } + public parenthesizedRelation(): ParenthesizedRelationContext | undefined { + return this.tryGetRuleContext(0, ParenthesizedRelationContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_relationPrimary; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRelationPrimary) { + listener.enterRelationPrimary(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRelationPrimary) { + listener.exitRelationPrimary(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRelationPrimary) { + return visitor.visitRelationPrimary(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SubQueryRelationContext extends ParserRuleContext { + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public queryStatement(): QueryStatementContext { + return this.getRuleContext(0, QueryStatementContext); + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_subQueryRelation; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSubQueryRelation) { + listener.enterSubQueryRelation(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSubQueryRelation) { + listener.exitSubQueryRelation(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSubQueryRelation) { + return visitor.visitSubQueryRelation(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UnnestContext extends ParserRuleContext { + public KW_UNNEST(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_UNNEST, 0); } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_WITH, 0); } + public KW_ORDINALITY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ORDINALITY, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_unnest; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterUnnest) { + listener.enterUnnest(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitUnnest) { + listener.exitUnnest(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitUnnest) { + return visitor.visitUnnest(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ParenthesizedRelationContext extends ParserRuleContext { + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public relation(): RelationContext { + return this.getRuleContext(0, RelationContext); + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_parenthesizedRelation; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterParenthesizedRelation) { + listener.enterParenthesizedRelation(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitParenthesizedRelation) { + listener.exitParenthesizedRelation(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitParenthesizedRelation) { + return visitor.visitParenthesizedRelation(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ColumnItemContext extends ParserRuleContext { + public columnNamePath(): ColumnNamePathContext | undefined { + return this.tryGetRuleContext(0, ColumnNamePathContext); + } + public expression(): ExpressionContext | undefined { + return this.tryGetRuleContext(0, ExpressionContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_columnItem; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterColumnItem) { + listener.enterColumnItem(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitColumnItem) { + listener.exitColumnItem(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitColumnItem) { + return visitor.visitColumnItem(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ExpressionContext extends ParserRuleContext { + public booleanExpression(): BooleanExpressionContext { + return this.getRuleContext(0, BooleanExpressionContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_expression; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterExpression) { + listener.enterExpression(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitExpression) { + listener.exitExpression(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitExpression) { + return visitor.visitExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class BooleanExpressionContext extends ParserRuleContext { + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_booleanExpression; } + public copyFrom(ctx: BooleanExpressionContext): void { + super.copyFrom(ctx); + } +} +export class PredicatedContext extends BooleanExpressionContext { + public _valueExpression!: ValueExpressionContext; + public valueExpression(): ValueExpressionContext { + return this.getRuleContext(0, ValueExpressionContext); + } + public predicate(): PredicateContext | undefined { + return this.tryGetRuleContext(0, PredicateContext); + } + constructor(ctx: BooleanExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterPredicated) { + listener.enterPredicated(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitPredicated) { + listener.exitPredicated(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitPredicated) { + return visitor.visitPredicated(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class LogicalNotContext extends BooleanExpressionContext { + public KW_NOT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_NOT, 0); } + public booleanExpression(): BooleanExpressionContext { + return this.getRuleContext(0, BooleanExpressionContext); + } + constructor(ctx: BooleanExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterLogicalNot) { + listener.enterLogicalNot(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitLogicalNot) { + listener.exitLogicalNot(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitLogicalNot) { + return visitor.visitLogicalNot(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class LogicalBinaryContext extends BooleanExpressionContext { + public _left!: BooleanExpressionContext; + public _operator!: Token; + public _right!: BooleanExpressionContext; + public booleanExpression(): BooleanExpressionContext[]; + public booleanExpression(i: number): BooleanExpressionContext; + public booleanExpression(i?: number): BooleanExpressionContext | BooleanExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(BooleanExpressionContext); + } else { + return this.getRuleContext(i, BooleanExpressionContext); + } + } + public KW_AND(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_AND, 0); } + public KW_OR(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_OR, 0); } + constructor(ctx: BooleanExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterLogicalBinary) { + listener.enterLogicalBinary(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitLogicalBinary) { + listener.exitLogicalBinary(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitLogicalBinary) { + return visitor.visitLogicalBinary(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PredicateContext extends ParserRuleContext { + public value: ParserRuleContext; + constructor(parent: ParserRuleContext | undefined, invokingState: number, value: ParserRuleContext) { + super(parent, invokingState); + this.value = value; + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_predicate; } + public copyFrom(ctx: PredicateContext): void { + super.copyFrom(ctx); + this.value = ctx.value; + } +} +export class ComparisonContext extends PredicateContext { + public _right!: ValueExpressionContext; + public comparisonOperator(): ComparisonOperatorContext { + return this.getRuleContext(0, ComparisonOperatorContext); + } + public valueExpression(): ValueExpressionContext { + return this.getRuleContext(0, ValueExpressionContext); + } + constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterComparison) { + listener.enterComparison(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitComparison) { + listener.exitComparison(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitComparison) { + return visitor.visitComparison(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class QuantifiedComparisonContext extends PredicateContext { + public comparisonOperator(): ComparisonOperatorContext { + return this.getRuleContext(0, ComparisonOperatorContext); + } + public comparisonQuantifier(): ComparisonQuantifierContext { + return this.getRuleContext(0, ComparisonQuantifierContext); + } + public subQueryRelation(): SubQueryRelationContext { + return this.getRuleContext(0, SubQueryRelationContext); + } + constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterQuantifiedComparison) { + listener.enterQuantifiedComparison(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitQuantifiedComparison) { + listener.exitQuantifiedComparison(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitQuantifiedComparison) { + return visitor.visitQuantifiedComparison(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class BetweenContext extends PredicateContext { + public _lower!: ValueExpressionContext; + public _upper!: ValueExpressionContext; + public KW_BETWEEN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_BETWEEN, 0); } + public KW_AND(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_AND, 0); } + public valueExpression(): ValueExpressionContext[]; + public valueExpression(i: number): ValueExpressionContext; + public valueExpression(i?: number): ValueExpressionContext | ValueExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ValueExpressionContext); + } else { + return this.getRuleContext(i, ValueExpressionContext); + } + } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NOT, 0); } + constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterBetween) { + listener.enterBetween(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitBetween) { + listener.exitBetween(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitBetween) { + return visitor.visitBetween(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class InListContext extends PredicateContext { + public KW_IN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_IN, 0); } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NOT, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterInList) { + listener.enterInList(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitInList) { + listener.exitInList(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitInList) { + return visitor.visitInList(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class InSubqueryContext extends PredicateContext { + public KW_IN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_IN, 0); } + public subQueryRelation(): SubQueryRelationContext { + return this.getRuleContext(0, SubQueryRelationContext); + } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NOT, 0); } + constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterInSubquery) { + listener.enterInSubquery(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitInSubquery) { + listener.exitInSubquery(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitInSubquery) { + return visitor.visitInSubquery(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class LikeContext extends PredicateContext { + public _pattern!: ValueExpressionContext; + public _escape!: ValueExpressionContext; + public KW_LIKE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_LIKE, 0); } + public valueExpression(): ValueExpressionContext[]; + public valueExpression(i: number): ValueExpressionContext; + public valueExpression(i?: number): ValueExpressionContext | ValueExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ValueExpressionContext); + } else { + return this.getRuleContext(i, ValueExpressionContext); + } + } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NOT, 0); } + public KW_ESCAPE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ESCAPE, 0); } + constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterLike) { + listener.enterLike(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitLike) { + listener.exitLike(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitLike) { + return visitor.visitLike(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class REGEXPContext extends PredicateContext { + public _pattern!: ValueExpressionContext; + public KW_REGEXP(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_REGEXP, 0); } + public valueExpression(): ValueExpressionContext { + return this.getRuleContext(0, ValueExpressionContext); + } + constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterREGEXP) { + listener.enterREGEXP(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitREGEXP) { + listener.exitREGEXP(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitREGEXP) { + return visitor.visitREGEXP(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class NullPredicateContext extends PredicateContext { + public KW_IS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_IS, 0); } + public KW_NULL(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_NULL, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NOT, 0); } + constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterNullPredicate) { + listener.enterNullPredicate(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitNullPredicate) { + listener.exitNullPredicate(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitNullPredicate) { + return visitor.visitNullPredicate(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DistinctFromContext extends PredicateContext { + public _right!: ValueExpressionContext; + public KW_IS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_IS, 0); } + public KW_DISTINCT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_DISTINCT, 0); } + public KW_FROM(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_FROM, 0); } + public valueExpression(): ValueExpressionContext { + return this.getRuleContext(0, ValueExpressionContext); + } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NOT, 0); } + constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDistinctFrom) { + listener.enterDistinctFrom(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDistinctFrom) { + listener.exitDistinctFrom(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDistinctFrom) { + return visitor.visitDistinctFrom(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ValueExpressionContext extends ParserRuleContext { + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_valueExpression; } + public copyFrom(ctx: ValueExpressionContext): void { + super.copyFrom(ctx); + } +} +export class ValueExpressionDefaultContext extends ValueExpressionContext { + public primaryExpression(): PrimaryExpressionContext { + return this.getRuleContext(0, PrimaryExpressionContext); + } + constructor(ctx: ValueExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterValueExpressionDefault) { + listener.enterValueExpressionDefault(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitValueExpressionDefault) { + listener.exitValueExpressionDefault(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitValueExpressionDefault) { + return visitor.visitValueExpressionDefault(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ArithmeticUnaryContext extends ValueExpressionContext { + public _operator!: Token; + public valueExpression(): ValueExpressionContext { + return this.getRuleContext(0, ValueExpressionContext); + } + public MINUS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.MINUS, 0); } + public PLUS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.PLUS, 0); } + constructor(ctx: ValueExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterArithmeticUnary) { + listener.enterArithmeticUnary(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitArithmeticUnary) { + listener.exitArithmeticUnary(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitArithmeticUnary) { + return visitor.visitArithmeticUnary(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ArithmeticBinaryContext extends ValueExpressionContext { + public _left!: ValueExpressionContext; + public _operator!: Token; + public _right!: ValueExpressionContext; + public valueExpression(): ValueExpressionContext[]; + public valueExpression(i: number): ValueExpressionContext; + public valueExpression(i?: number): ValueExpressionContext | ValueExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ValueExpressionContext); + } else { + return this.getRuleContext(i, ValueExpressionContext); + } + } + public ASTERISK(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.ASTERISK, 0); } + public SLASH(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.SLASH, 0); } + public PERCENT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.PERCENT, 0); } + public PLUS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.PLUS, 0); } + public MINUS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.MINUS, 0); } + constructor(ctx: ValueExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterArithmeticBinary) { + listener.enterArithmeticBinary(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitArithmeticBinary) { + listener.exitArithmeticBinary(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitArithmeticBinary) { + return visitor.visitArithmeticBinary(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ConcatenationContext extends ValueExpressionContext { + public _left!: ValueExpressionContext; + public _right!: ValueExpressionContext; + public CONCAT(): TerminalNode { return this.getToken(ImpalaSqlParser.CONCAT, 0); } + public valueExpression(): ValueExpressionContext[]; + public valueExpression(i: number): ValueExpressionContext; + public valueExpression(i?: number): ValueExpressionContext | ValueExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ValueExpressionContext); + } else { + return this.getRuleContext(i, ValueExpressionContext); + } + } + constructor(ctx: ValueExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterConcatenation) { + listener.enterConcatenation(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitConcatenation) { + listener.exitConcatenation(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitConcatenation) { + return visitor.visitConcatenation(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PrimaryExpressionContext extends ParserRuleContext { + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_primaryExpression; } + public copyFrom(ctx: PrimaryExpressionContext): void { + super.copyFrom(ctx); + } +} +export class NullLiteralContext extends PrimaryExpressionContext { + public KW_NULL(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_NULL, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterNullLiteral) { + listener.enterNullLiteral(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitNullLiteral) { + listener.exitNullLiteral(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitNullLiteral) { + return visitor.visitNullLiteral(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class IntervalLiteralContext extends PrimaryExpressionContext { + public interval(): IntervalContext { + return this.getRuleContext(0, IntervalContext); + } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterIntervalLiteral) { + listener.enterIntervalLiteral(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitIntervalLiteral) { + listener.exitIntervalLiteral(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitIntervalLiteral) { + return visitor.visitIntervalLiteral(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class TypeConstructorContext extends PrimaryExpressionContext { + public identifier(): IdentifierContext | undefined { + return this.tryGetRuleContext(0, IdentifierContext); + } + public stringLiteral(): StringLiteralContext { + return this.getRuleContext(0, StringLiteralContext); + } + public DOUBLE_PRECISION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.DOUBLE_PRECISION, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterTypeConstructor) { + listener.enterTypeConstructor(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitTypeConstructor) { + listener.exitTypeConstructor(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitTypeConstructor) { + return visitor.visitTypeConstructor(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class NumericLiteralContext extends PrimaryExpressionContext { + public number(): NumberContext { + return this.getRuleContext(0, NumberContext); + } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterNumericLiteral) { + listener.enterNumericLiteral(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitNumericLiteral) { + listener.exitNumericLiteral(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitNumericLiteral) { + return visitor.visitNumericLiteral(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class BooleanLiteralContext extends PrimaryExpressionContext { + public booleanValue(): BooleanValueContext { + return this.getRuleContext(0, BooleanValueContext); + } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterBooleanLiteral) { + listener.enterBooleanLiteral(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitBooleanLiteral) { + listener.exitBooleanLiteral(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitBooleanLiteral) { + return visitor.visitBooleanLiteral(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class StringLiteralValuesContext extends PrimaryExpressionContext { + public stringLiteral(): StringLiteralContext { + return this.getRuleContext(0, StringLiteralContext); + } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterStringLiteralValues) { + listener.enterStringLiteralValues(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitStringLiteralValues) { + listener.exitStringLiteralValues(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitStringLiteralValues) { + return visitor.visitStringLiteralValues(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class BinaryLiteralContext extends PrimaryExpressionContext { + public BINARY_LITERAL(): TerminalNode { return this.getToken(ImpalaSqlParser.BINARY_LITERAL, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterBinaryLiteral) { + listener.enterBinaryLiteral(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitBinaryLiteral) { + listener.exitBinaryLiteral(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitBinaryLiteral) { + return visitor.visitBinaryLiteral(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ParameterContext extends PrimaryExpressionContext { + public QUESTION(): TerminalNode { return this.getToken(ImpalaSqlParser.QUESTION, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterParameter) { + listener.enterParameter(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitParameter) { + listener.exitParameter(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitParameter) { + return visitor.visitParameter(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class PositionContext extends PrimaryExpressionContext { + public KW_POSITION(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_POSITION, 0); } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public valueExpression(): ValueExpressionContext[]; + public valueExpression(i: number): ValueExpressionContext; + public valueExpression(i?: number): ValueExpressionContext | ValueExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ValueExpressionContext); + } else { + return this.getRuleContext(i, ValueExpressionContext); + } + } + public KW_IN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_IN, 0); } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterPosition) { + listener.enterPosition(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitPosition) { + listener.exitPosition(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitPosition) { + return visitor.visitPosition(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class RowConstructorContext extends PrimaryExpressionContext { + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public KW_AS(): TerminalNode[]; + public KW_AS(i: number): TerminalNode; + public KW_AS(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.KW_AS); + } else { + return this.getToken(ImpalaSqlParser.KW_AS, i); + } + } + public type(): TypeContext[]; + public type(i: number): TypeContext; + public type(i?: number): TypeContext | TypeContext[] { + if (i === undefined) { + return this.getRuleContexts(TypeContext); + } else { + return this.getRuleContext(i, TypeContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROW, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRowConstructor) { + listener.enterRowConstructor(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRowConstructor) { + listener.exitRowConstructor(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRowConstructor) { + return visitor.visitRowConstructor(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class FunctionCallContext extends PrimaryExpressionContext { + public functionNamePath(): FunctionNamePathContext { + return this.getRuleContext(0, FunctionNamePathContext); + } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public ASTERISK(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.ASTERISK, 0); } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public filter(): FilterContext | undefined { + return this.tryGetRuleContext(0, FilterContext); + } + public over(): OverContext | undefined { + return this.tryGetRuleContext(0, OverContext); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ORDER, 0); } + public KW_BY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_BY, 0); } + public sortItem(): SortItemContext[]; + public sortItem(i: number): SortItemContext; + public sortItem(i?: number): SortItemContext | SortItemContext[] { + if (i === undefined) { + return this.getRuleContexts(SortItemContext); + } else { + return this.getRuleContext(i, SortItemContext); + } + } + public setQuantifier(): SetQuantifierContext | undefined { + return this.tryGetRuleContext(0, SetQuantifierContext); + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterFunctionCall) { + listener.enterFunctionCall(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitFunctionCall) { + listener.exitFunctionCall(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitFunctionCall) { + return visitor.visitFunctionCall(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class LambdaContext extends PrimaryExpressionContext { + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext; + public identifier(i?: number): IdentifierContext | IdentifierContext[] { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } else { + return this.getRuleContext(i, IdentifierContext); + } + } + public RIGHT_ARROW(): TerminalNode { return this.getToken(ImpalaSqlParser.RIGHT_ARROW, 0); } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext); + } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterLambda) { + listener.enterLambda(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitLambda) { + listener.exitLambda(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitLambda) { + return visitor.visitLambda(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class SubqueryExpressionContext extends PrimaryExpressionContext { + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public queryStatement(): QueryStatementContext { + return this.getRuleContext(0, QueryStatementContext); + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSubqueryExpression) { + listener.enterSubqueryExpression(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSubqueryExpression) { + listener.exitSubqueryExpression(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSubqueryExpression) { + return visitor.visitSubqueryExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ExistsContext extends PrimaryExpressionContext { + public KW_EXISTS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_EXISTS, 0); } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public queryStatement(): QueryStatementContext { + return this.getRuleContext(0, QueryStatementContext); + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterExists) { + listener.enterExists(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitExists) { + listener.exitExists(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitExists) { + return visitor.visitExists(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class SimpleCaseContext extends PrimaryExpressionContext { + public _elseExpression!: ExpressionContext; + public KW_CASE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CASE, 0); } + public valueExpression(): ValueExpressionContext { + return this.getRuleContext(0, ValueExpressionContext); + } + public KW_END(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_END, 0); } + public whenClause(): WhenClauseContext[]; + public whenClause(i: number): WhenClauseContext; + public whenClause(i?: number): WhenClauseContext | WhenClauseContext[] { + if (i === undefined) { + return this.getRuleContexts(WhenClauseContext); + } else { + return this.getRuleContext(i, WhenClauseContext); + } + } + public KW_ELSE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ELSE, 0); } + public expression(): ExpressionContext | undefined { + return this.tryGetRuleContext(0, ExpressionContext); + } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSimpleCase) { + listener.enterSimpleCase(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSimpleCase) { + listener.exitSimpleCase(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSimpleCase) { + return visitor.visitSimpleCase(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class SearchedCaseContext extends PrimaryExpressionContext { + public _elseExpression!: ExpressionContext; + public KW_CASE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CASE, 0); } + public KW_END(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_END, 0); } + public whenClause(): WhenClauseContext[]; + public whenClause(i: number): WhenClauseContext; + public whenClause(i?: number): WhenClauseContext | WhenClauseContext[] { + if (i === undefined) { + return this.getRuleContexts(WhenClauseContext); + } else { + return this.getRuleContext(i, WhenClauseContext); + } + } + public KW_ELSE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ELSE, 0); } + public expression(): ExpressionContext | undefined { + return this.tryGetRuleContext(0, ExpressionContext); + } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSearchedCase) { + listener.enterSearchedCase(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSearchedCase) { + listener.exitSearchedCase(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSearchedCase) { + return visitor.visitSearchedCase(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CastContext extends PrimaryExpressionContext { + public KW_CAST(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_CAST, 0); } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext); + } + public KW_AS(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_AS, 0); } + public type(): TypeContext { + return this.getRuleContext(0, TypeContext); + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public KW_TRY_CAST(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TRY_CAST, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCast) { + listener.enterCast(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCast) { + listener.exitCast(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCast) { + return visitor.visitCast(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ArrayConstructorContext extends PrimaryExpressionContext { + public KW_ARRAY(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ARRAY, 0); } + public LSQUARE(): TerminalNode { return this.getToken(ImpalaSqlParser.LSQUARE, 0); } + public RSQUARE(): TerminalNode { return this.getToken(ImpalaSqlParser.RSQUARE, 0); } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterArrayConstructor) { + listener.enterArrayConstructor(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitArrayConstructor) { + listener.exitArrayConstructor(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitArrayConstructor) { + return visitor.visitArrayConstructor(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class SubscriptContext extends PrimaryExpressionContext { + public _value!: PrimaryExpressionContext; + public _index!: ValueExpressionContext; + public LSQUARE(): TerminalNode { return this.getToken(ImpalaSqlParser.LSQUARE, 0); } + public RSQUARE(): TerminalNode { return this.getToken(ImpalaSqlParser.RSQUARE, 0); } + public primaryExpression(): PrimaryExpressionContext { + return this.getRuleContext(0, PrimaryExpressionContext); + } + public valueExpression(): ValueExpressionContext { + return this.getRuleContext(0, ValueExpressionContext); + } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSubscript) { + listener.enterSubscript(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSubscript) { + listener.exitSubscript(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSubscript) { + return visitor.visitSubscript(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ColumnReferenceContext extends PrimaryExpressionContext { + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterColumnReference) { + listener.enterColumnReference(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitColumnReference) { + listener.exitColumnReference(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitColumnReference) { + return visitor.visitColumnReference(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DereferenceContext extends PrimaryExpressionContext { + public _base!: PrimaryExpressionContext; + public _fieldName!: IdentifierContext; + public DOT(): TerminalNode { return this.getToken(ImpalaSqlParser.DOT, 0); } + public primaryExpression(): PrimaryExpressionContext { + return this.getRuleContext(0, PrimaryExpressionContext); + } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDereference) { + listener.enterDereference(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDereference) { + listener.exitDereference(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDereference) { + return visitor.visitDereference(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class SpecialDateTimeFunctionContext extends PrimaryExpressionContext { + public _name!: Token; + public _precision!: Token; + public KW_CURRENT_DATE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_CURRENT_DATE, 0); } + public KW_CURRENT_TIME(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_CURRENT_TIME, 0); } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public INTEGER_VALUE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.INTEGER_VALUE, 0); } + public KW_CURRENT_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_CURRENT_TIMESTAMP, 0); } + public KW_LOCALTIME(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LOCALTIME, 0); } + public KW_LOCALTIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LOCALTIMESTAMP, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSpecialDateTimeFunction) { + listener.enterSpecialDateTimeFunction(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSpecialDateTimeFunction) { + listener.exitSpecialDateTimeFunction(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSpecialDateTimeFunction) { + return visitor.visitSpecialDateTimeFunction(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CurrentUserContext extends PrimaryExpressionContext { + public _name!: Token; + public KW_CURRENT_USER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CURRENT_USER, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCurrentUser) { + listener.enterCurrentUser(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCurrentUser) { + listener.exitCurrentUser(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCurrentUser) { + return visitor.visitCurrentUser(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CurrentPathContext extends PrimaryExpressionContext { + public _name!: Token; + public KW_CURRENT_PATH(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CURRENT_PATH, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCurrentPath) { + listener.enterCurrentPath(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCurrentPath) { + listener.exitCurrentPath(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCurrentPath) { + return visitor.visitCurrentPath(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class SubstringContext extends PrimaryExpressionContext { + public KW_SUBSTRING(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_SUBSTRING, 0); } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public valueExpression(): ValueExpressionContext[]; + public valueExpression(i: number): ValueExpressionContext; + public valueExpression(i?: number): ValueExpressionContext | ValueExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ValueExpressionContext); + } else { + return this.getRuleContext(i, ValueExpressionContext); + } + } + public KW_FROM(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_FROM, 0); } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FOR, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterSubstring) { + listener.enterSubstring(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitSubstring) { + listener.exitSubstring(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitSubstring) { + return visitor.visitSubstring(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class NormalizeContext extends PrimaryExpressionContext { + public KW_NORMALIZE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_NORMALIZE, 0); } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public valueExpression(): ValueExpressionContext { + return this.getRuleContext(0, ValueExpressionContext); + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public COMMA(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.COMMA, 0); } + public normalForm(): NormalFormContext | undefined { + return this.tryGetRuleContext(0, NormalFormContext); + } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterNormalize) { + listener.enterNormalize(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitNormalize) { + listener.exitNormalize(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitNormalize) { + return visitor.visitNormalize(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ExtractContext extends PrimaryExpressionContext { + public KW_EXTRACT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_EXTRACT, 0); } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + public KW_FROM(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_FROM, 0); } + public valueExpression(): ValueExpressionContext { + return this.getRuleContext(0, ValueExpressionContext); + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterExtract) { + listener.enterExtract(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitExtract) { + listener.exitExtract(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitExtract) { + return visitor.visitExtract(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ParenthesizedExpressionContext extends PrimaryExpressionContext { + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext); + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterParenthesizedExpression) { + listener.enterParenthesizedExpression(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitParenthesizedExpression) { + listener.exitParenthesizedExpression(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitParenthesizedExpression) { + return visitor.visitParenthesizedExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class GroupingOperationContext extends PrimaryExpressionContext { + public KW_GROUPING(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_GROUPING, 0); } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public qualifiedName(): QualifiedNameContext[]; + public qualifiedName(i: number): QualifiedNameContext; + public qualifiedName(i?: number): QualifiedNameContext | QualifiedNameContext[] { + if (i === undefined) { + return this.getRuleContexts(QualifiedNameContext); + } else { + return this.getRuleContext(i, QualifiedNameContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(ctx: PrimaryExpressionContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterGroupingOperation) { + listener.enterGroupingOperation(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitGroupingOperation) { + listener.exitGroupingOperation(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitGroupingOperation) { + return visitor.visitGroupingOperation(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class StringLiteralContext extends ParserRuleContext { + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_stringLiteral; } + public copyFrom(ctx: StringLiteralContext): void { + super.copyFrom(ctx); + } +} +export class BasicStringLiteralContext extends StringLiteralContext { + public STRING(): TerminalNode { return this.getToken(ImpalaSqlParser.STRING, 0); } + constructor(ctx: StringLiteralContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterBasicStringLiteral) { + listener.enterBasicStringLiteral(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitBasicStringLiteral) { + listener.exitBasicStringLiteral(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitBasicStringLiteral) { + return visitor.visitBasicStringLiteral(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class UnicodeStringLiteralContext extends StringLiteralContext { + public UNICODE_STRING(): TerminalNode { return this.getToken(ImpalaSqlParser.UNICODE_STRING, 0); } + public KW_UESCAPE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_UESCAPE, 0); } + public STRING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.STRING, 0); } + constructor(ctx: StringLiteralContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterUnicodeStringLiteral) { + listener.enterUnicodeStringLiteral(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitUnicodeStringLiteral) { + listener.exitUnicodeStringLiteral(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitUnicodeStringLiteral) { + return visitor.visitUnicodeStringLiteral(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ComparisonOperatorContext extends ParserRuleContext { + public EQ(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.EQ, 0); } + public NEQ(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.NEQ, 0); } + public LT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LT, 0); } + public LTE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LTE, 0); } + public GT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.GT, 0); } + public GTE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.GTE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_comparisonOperator; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterComparisonOperator) { + listener.enterComparisonOperator(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitComparisonOperator) { + listener.exitComparisonOperator(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitComparisonOperator) { + return visitor.visitComparisonOperator(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ComparisonQuantifierContext extends ParserRuleContext { + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ALL, 0); } + public KW_SOME(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SOME, 0); } + public KW_ANY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ANY, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_comparisonQuantifier; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterComparisonQuantifier) { + listener.enterComparisonQuantifier(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitComparisonQuantifier) { + listener.exitComparisonQuantifier(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitComparisonQuantifier) { + return visitor.visitComparisonQuantifier(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class BooleanValueContext extends ParserRuleContext { + public KW_TRUE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TRUE, 0); } + public KW_FALSE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FALSE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_booleanValue; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterBooleanValue) { + listener.enterBooleanValue(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitBooleanValue) { + listener.exitBooleanValue(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitBooleanValue) { + return visitor.visitBooleanValue(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IntervalContext extends ParserRuleContext { + public INTEGER_VALUE(): TerminalNode { return this.getToken(ImpalaSqlParser.INTEGER_VALUE, 0); } + public intervalField(): IntervalFieldContext { + return this.getRuleContext(0, IntervalFieldContext); + } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public KW_INTERVAL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_INTERVAL, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_interval; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterInterval) { + listener.enterInterval(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitInterval) { + listener.exitInterval(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitInterval) { + return visitor.visitInterval(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IntervalFieldContext extends ParserRuleContext { + public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_YEAR, 0); } + public KW_YEARS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_YEARS, 0); } + public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_MONTH, 0); } + public KW_MONTHS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_MONTHS, 0); } + public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DAY, 0); } + public KW_DAYS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DAYS, 0); } + public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_HOUR, 0); } + public KW_HOURS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_HOURS, 0); } + public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_MINUTE, 0); } + public KW_MINUTES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_MINUTES, 0); } + public KW_SECOND(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SECOND, 0); } + public KW_SECONDS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SECONDS, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_intervalField; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterIntervalField) { + listener.enterIntervalField(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitIntervalField) { + listener.exitIntervalField(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitIntervalField) { + return visitor.visitIntervalField(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NormalFormContext extends ParserRuleContext { + public KW_NFD(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NFD, 0); } + public KW_NFC(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NFC, 0); } + public KW_NFKD(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NFKD, 0); } + public KW_NFKC(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NFKC, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_normalForm; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterNormalForm) { + listener.enterNormalForm(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitNormalForm) { + listener.exitNormalForm(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitNormalForm) { + return visitor.visitNormalForm(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TypeContext extends ParserRuleContext { + public type(): TypeContext[]; + public type(i: number): TypeContext; + public type(i?: number): TypeContext | TypeContext[] { + if (i === undefined) { + return this.getRuleContexts(TypeContext); + } else { + return this.getRuleContext(i, TypeContext); + } + } + public KW_ARRAY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ARRAY, 0); } + public LT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LT, 0); } + public GT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.GT, 0); } + public KW_MAP(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_MAP, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + public KW_STRUCT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_STRUCT, 0); } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext; + public identifier(i?: number): IdentifierContext | IdentifierContext[] { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } else { + return this.getRuleContext(i, IdentifierContext); + } + } + public COLON(): TerminalNode[]; + public COLON(i: number): TerminalNode; + public COLON(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COLON); + } else { + return this.getToken(ImpalaSqlParser.COLON, i); + } + } + public baseType(): BaseTypeContext | undefined { + return this.tryGetRuleContext(0, BaseTypeContext); + } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public typeParameter(): TypeParameterContext[]; + public typeParameter(i: number): TypeParameterContext; + public typeParameter(i?: number): TypeParameterContext | TypeParameterContext[] { + if (i === undefined) { + return this.getRuleContexts(TypeParameterContext); + } else { + return this.getRuleContext(i, TypeParameterContext); + } + } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_type; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterType) { + listener.enterType(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitType) { + listener.exitType(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitType) { + return visitor.visitType(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TypeParameterContext extends ParserRuleContext { + public INTEGER_VALUE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.INTEGER_VALUE, 0); } + public type(): TypeContext | undefined { + return this.tryGetRuleContext(0, TypeContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_typeParameter; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterTypeParameter) { + listener.enterTypeParameter(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitTypeParameter) { + listener.exitTypeParameter(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitTypeParameter) { + return visitor.visitTypeParameter(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class BaseTypeContext extends ParserRuleContext { + public TIME_WITH_TIME_ZONE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.TIME_WITH_TIME_ZONE, 0); } + public TIMESTAMP_WITH_TIME_ZONE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.TIMESTAMP_WITH_TIME_ZONE, 0); } + public DOUBLE_PRECISION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.DOUBLE_PRECISION, 0); } + public identifier(): IdentifierContext | undefined { + return this.tryGetRuleContext(0, IdentifierContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_baseType; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterBaseType) { + listener.enterBaseType(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitBaseType) { + listener.exitBaseType(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitBaseType) { + return visitor.visitBaseType(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WhenClauseContext extends ParserRuleContext { + public _condition!: ExpressionContext; + public _result!: ExpressionContext; + public KW_WHEN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_WHEN, 0); } + public KW_THEN(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_THEN, 0); } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_whenClause; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterWhenClause) { + listener.enterWhenClause(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitWhenClause) { + listener.exitWhenClause(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitWhenClause) { + return visitor.visitWhenClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FilterContext extends ParserRuleContext { + public KW_FILTER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_FILTER, 0); } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public KW_WHERE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_WHERE, 0); } + public booleanExpression(): BooleanExpressionContext { + return this.getRuleContext(0, BooleanExpressionContext); + } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_filter; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterFilter) { + listener.enterFilter(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitFilter) { + listener.exitFilter(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitFilter) { + return visitor.visitFilter(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class OverContext extends ParserRuleContext { + public _expression!: ExpressionContext; + public _partition: ExpressionContext[] = []; + public KW_OVER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_OVER, 0); } + public LPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.LPAREN, 0); } + public RPAREN(): TerminalNode { return this.getToken(ImpalaSqlParser.RPAREN, 0); } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITION, 0); } + public KW_BY(): TerminalNode[]; + public KW_BY(i: number): TerminalNode; + public KW_BY(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.KW_BY); + } else { + return this.getToken(ImpalaSqlParser.KW_BY, i); + } + } + public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ORDER, 0); } + public sortItem(): SortItemContext[]; + public sortItem(i: number): SortItemContext; + public sortItem(i?: number): SortItemContext | SortItemContext[] { + if (i === undefined) { + return this.getRuleContexts(SortItemContext); + } else { + return this.getRuleContext(i, SortItemContext); + } + } + public windowFrame(): WindowFrameContext | undefined { + return this.tryGetRuleContext(0, WindowFrameContext); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext; + public expression(i?: number): ExpressionContext | ExpressionContext[] { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } else { + return this.getRuleContext(i, ExpressionContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_over; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterOver) { + listener.enterOver(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitOver) { + listener.exitOver(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitOver) { + return visitor.visitOver(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WindowFrameContext extends ParserRuleContext { + public _frameType!: Token; + public _start_!: FrameBoundContext; + public _end!: FrameBoundContext; + public KW_RANGE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RANGE, 0); } + public frameBound(): FrameBoundContext[]; + public frameBound(i: number): FrameBoundContext; + public frameBound(i?: number): FrameBoundContext | FrameBoundContext[] { + if (i === undefined) { + return this.getRuleContexts(FrameBoundContext); + } else { + return this.getRuleContext(i, FrameBoundContext); + } + } + public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROWS, 0); } + public KW_BETWEEN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_BETWEEN, 0); } + public KW_AND(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_AND, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_windowFrame; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterWindowFrame) { + listener.enterWindowFrame(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitWindowFrame) { + listener.exitWindowFrame(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitWindowFrame) { + return visitor.visitWindowFrame(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FrameBoundContext extends ParserRuleContext { + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_frameBound; } + public copyFrom(ctx: FrameBoundContext): void { + super.copyFrom(ctx); + } +} +export class UnboundedFrameContext extends FrameBoundContext { + public _boundType!: Token; + public KW_UNBOUNDED(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_UNBOUNDED, 0); } + public KW_PRECEDING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PRECEDING, 0); } + public KW_FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FOLLOWING, 0); } + constructor(ctx: FrameBoundContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterUnboundedFrame) { + listener.enterUnboundedFrame(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitUnboundedFrame) { + listener.exitUnboundedFrame(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitUnboundedFrame) { + return visitor.visitUnboundedFrame(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CurrentRowBoundContext extends FrameBoundContext { + public KW_CURRENT(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_CURRENT, 0); } + public KW_ROW(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ROW, 0); } + constructor(ctx: FrameBoundContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterCurrentRowBound) { + listener.enterCurrentRowBound(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitCurrentRowBound) { + listener.exitCurrentRowBound(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitCurrentRowBound) { + return visitor.visitCurrentRowBound(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class BoundedFrameContext extends FrameBoundContext { + public _boundType!: Token; + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext); + } + public KW_PRECEDING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PRECEDING, 0); } + public KW_FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FOLLOWING, 0); } + constructor(ctx: FrameBoundContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterBoundedFrame) { + listener.enterBoundedFrame(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitBoundedFrame) { + listener.exitBoundedFrame(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitBoundedFrame) { + return visitor.visitBoundedFrame(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PathElementContext extends ParserRuleContext { + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_pathElement; } + public copyFrom(ctx: PathElementContext): void { + super.copyFrom(ctx); + } +} +export class QualifiedArgumentContext extends PathElementContext { + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext; + public identifier(i?: number): IdentifierContext | IdentifierContext[] { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } else { + return this.getRuleContext(i, IdentifierContext); + } + } + public DOT(): TerminalNode { return this.getToken(ImpalaSqlParser.DOT, 0); } + constructor(ctx: PathElementContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterQualifiedArgument) { + listener.enterQualifiedArgument(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitQualifiedArgument) { + listener.exitQualifiedArgument(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitQualifiedArgument) { + return visitor.visitQualifiedArgument(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class UnqualifiedArgumentContext extends PathElementContext { + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + constructor(ctx: PathElementContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterUnqualifiedArgument) { + listener.enterUnqualifiedArgument(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitUnqualifiedArgument) { + listener.exitUnqualifiedArgument(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitUnqualifiedArgument) { + return visitor.visitUnqualifiedArgument(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PathSpecificationContext extends ParserRuleContext { + public pathElement(): PathElementContext[]; + public pathElement(i: number): PathElementContext; + public pathElement(i?: number): PathElementContext | PathElementContext[] { + if (i === undefined) { + return this.getRuleContexts(PathElementContext); + } else { + return this.getRuleContext(i, PathElementContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.COMMA); + } else { + return this.getToken(ImpalaSqlParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_pathSpecification; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterPathSpecification) { + listener.enterPathSpecification(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitPathSpecification) { + listener.exitPathSpecification(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitPathSpecification) { + return visitor.visitPathSpecification(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PrivilegeContext extends ParserRuleContext { + public _columnName!: IdentifierContext; + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ALL, 0); } + public KW_ALTER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ALTER, 0); } + public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DROP, 0); } + public KW_CREATE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_CREATE, 0); } + public KW_INSERT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_INSERT, 0); } + public KW_REFRESH(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_REFRESH, 0); } + public KW_SELECT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SELECT, 0); } + public LPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.LPAREN, 0); } + public RPAREN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.RPAREN, 0); } + public identifier(): IdentifierContext | undefined { + return this.tryGetRuleContext(0, IdentifierContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_privilege; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterPrivilege) { + listener.enterPrivilege(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitPrivilege) { + listener.exitPrivilege(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitPrivilege) { + return visitor.visitPrivilege(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ObjectTypeContext extends ParserRuleContext { + public KW_SERVER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SERVER, 0); } + public KW_URI(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_URI, 0); } + public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DATABASE, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TABLE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_objectType; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterObjectType) { + listener.enterObjectType(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitObjectType) { + listener.exitObjectType(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitObjectType) { + return visitor.visitObjectType(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QualifiedNameContext extends ParserRuleContext { + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext; + public identifier(i?: number): IdentifierContext | IdentifierContext[] { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } else { + return this.getRuleContext(i, IdentifierContext); + } + } + public DOT(): TerminalNode[]; + public DOT(i: number): TerminalNode; + public DOT(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(ImpalaSqlParser.DOT); + } else { + return this.getToken(ImpalaSqlParser.DOT, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_qualifiedName; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterQualifiedName) { + listener.enterQualifiedName(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitQualifiedName) { + listener.exitQualifiedName(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitQualifiedName) { + return visitor.visitQualifiedName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PrincipalContext extends ParserRuleContext { + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_principal; } + public copyFrom(ctx: PrincipalContext): void { + super.copyFrom(ctx); + } +} +export class RolePrincipalContext extends PrincipalContext { + public KW_ROLE(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_ROLE, 0); } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + constructor(ctx: PrincipalContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterRolePrincipal) { + listener.enterRolePrincipal(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitRolePrincipal) { + listener.exitRolePrincipal(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitRolePrincipal) { + return visitor.visitRolePrincipal(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class UserPrincipalContext extends PrincipalContext { + public KW_USER(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_USER, 0); } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + constructor(ctx: PrincipalContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterUserPrincipal) { + listener.enterUserPrincipal(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitUserPrincipal) { + listener.exitUserPrincipal(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitUserPrincipal) { + return visitor.visitUserPrincipal(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class GroupPrincipalContext extends PrincipalContext { + public KW_GROUP(): TerminalNode { return this.getToken(ImpalaSqlParser.KW_GROUP, 0); } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + constructor(ctx: PrincipalContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterGroupPrincipal) { + listener.enterGroupPrincipal(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitGroupPrincipal) { + listener.exitGroupPrincipal(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitGroupPrincipal) { + return visitor.visitGroupPrincipal(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IdentifierContext extends ParserRuleContext { + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_identifier; } + public copyFrom(ctx: IdentifierContext): void { + super.copyFrom(ctx); + } +} +export class UnquotedIdentifierContext extends IdentifierContext { + public IDENTIFIER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.IDENTIFIER, 0); } + public nonReserved(): NonReservedContext | undefined { + return this.tryGetRuleContext(0, NonReservedContext); + } + constructor(ctx: IdentifierContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterUnquotedIdentifier) { + listener.enterUnquotedIdentifier(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitUnquotedIdentifier) { + listener.exitUnquotedIdentifier(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitUnquotedIdentifier) { + return visitor.visitUnquotedIdentifier(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class QuotedIdentifierContext extends IdentifierContext { + public STRING(): TerminalNode { return this.getToken(ImpalaSqlParser.STRING, 0); } + constructor(ctx: IdentifierContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterQuotedIdentifier) { + listener.enterQuotedIdentifier(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitQuotedIdentifier) { + listener.exitQuotedIdentifier(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitQuotedIdentifier) { + return visitor.visitQuotedIdentifier(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class BackQuotedIdentifierContext extends IdentifierContext { + public BACKQUOTED_IDENTIFIER(): TerminalNode { return this.getToken(ImpalaSqlParser.BACKQUOTED_IDENTIFIER, 0); } + constructor(ctx: IdentifierContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterBackQuotedIdentifier) { + listener.enterBackQuotedIdentifier(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitBackQuotedIdentifier) { + listener.exitBackQuotedIdentifier(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitBackQuotedIdentifier) { + return visitor.visitBackQuotedIdentifier(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DigitIdentifierContext extends IdentifierContext { + public DIGIT_IDENTIFIER(): TerminalNode { return this.getToken(ImpalaSqlParser.DIGIT_IDENTIFIER, 0); } + constructor(ctx: IdentifierContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDigitIdentifier) { + listener.enterDigitIdentifier(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDigitIdentifier) { + listener.exitDigitIdentifier(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDigitIdentifier) { + return visitor.visitDigitIdentifier(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NumberContext extends ParserRuleContext { + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_number; } + public copyFrom(ctx: NumberContext): void { + super.copyFrom(ctx); + } +} +export class DecimalLiteralContext extends NumberContext { + public DECIMAL_VALUE(): TerminalNode { return this.getToken(ImpalaSqlParser.DECIMAL_VALUE, 0); } + public MINUS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.MINUS, 0); } + constructor(ctx: NumberContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDecimalLiteral) { + listener.enterDecimalLiteral(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDecimalLiteral) { + listener.exitDecimalLiteral(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDecimalLiteral) { + return visitor.visitDecimalLiteral(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DoubleLiteralContext extends NumberContext { + public DOUBLE_VALUE(): TerminalNode { return this.getToken(ImpalaSqlParser.DOUBLE_VALUE, 0); } + public MINUS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.MINUS, 0); } + constructor(ctx: NumberContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterDoubleLiteral) { + listener.enterDoubleLiteral(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitDoubleLiteral) { + listener.exitDoubleLiteral(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitDoubleLiteral) { + return visitor.visitDoubleLiteral(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class IntegerLiteralContext extends NumberContext { + public INTEGER_VALUE(): TerminalNode { return this.getToken(ImpalaSqlParser.INTEGER_VALUE, 0); } + public MINUS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.MINUS, 0); } + constructor(ctx: NumberContext) { + super(ctx.parent, ctx.invokingState); + this.copyFrom(ctx); + } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterIntegerLiteral) { + listener.enterIntegerLiteral(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitIntegerLiteral) { + listener.exitIntegerLiteral(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitIntegerLiteral) { + return visitor.visitIntegerLiteral(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NonReservedContext extends ParserRuleContext { + public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ADD, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ALL, 0); } + public KW_ANY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ANY, 0); } + public KW_ARRAY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ARRAY, 0); } + public KW_ASC(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ASC, 0); } + public KW_AT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_AT, 0); } + public KW_BERNOULLI(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_BERNOULLI, 0); } + public KW_CASCADE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_CASCADE, 0); } + public KW_COLUMN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COLUMN, 0); } + public KW_COLUMNS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COLUMNS, 0); } + public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_COMMENT, 0); } + public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_CURRENT, 0); } + public KW_DATA(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DATA, 0); } + public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DATABASE, 0); } + public KW_DATABASES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DATABASES, 0); } + public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DAY, 0); } + public KW_DAYS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DAYS, 0); } + public KW_DESC(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DESC, 0); } + public KW_EXCLUDING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_EXCLUDING, 0); } + public KW_EXPLAIN(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_EXPLAIN, 0); } + public KW_FILTER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FILTER, 0); } + public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FIRST, 0); } + public KW_FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FOLLOWING, 0); } + public KW_FORMAT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FORMAT, 0); } + public KW_FUNCTIONS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_FUNCTIONS, 0); } + public KW_GRANT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_GRANT, 0); } + public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_HOUR, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_IF, 0); } + public KW_INCLUDING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_INCLUDING, 0); } + public KW_INTERVAL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_INTERVAL, 0); } + public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LAST, 0); } + public KW_LATERAL(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LATERAL, 0); } + public KW_LIMIT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_LIMIT, 0); } + public KW_MAP(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_MAP, 0); } + public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_MINUTE, 0); } + public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_MONTH, 0); } + public KW_NFC(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NFC, 0); } + public KW_NFD(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NFD, 0); } + public KW_NFKC(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NFKC, 0); } + public KW_NFKD(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NFKD, 0); } + public KW_NULLS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_NULLS, 0); } + public KW_OFFSET(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_OFFSET, 0); } + public KW_OPTION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_OPTION, 0); } + public KW_ORDINALITY(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ORDINALITY, 0); } + public KW_OVER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_OVER, 0); } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITION, 0); } + public KW_PARTITIONS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARTITIONS, 0); } + public KW_PARQUET(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PARQUET, 0); } + public KW_POSITION(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_POSITION, 0); } + public KW_PRECEDING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PRECEDING, 0); } + public KW_PRIVILEGES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PRIVILEGES, 0); } + public KW_PROPERTIES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_PROPERTIES, 0); } + public KW_RANGE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RANGE, 0); } + public KW_RENAME(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RENAME, 0); } + public KW_REPEATABLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_REPEATABLE, 0); } + public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_REPLACE, 0); } + public KW_RESTRICT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RESTRICT, 0); } + public KW_REVOKE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_REVOKE, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROLE, 0); } + public KW_ROLES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROLES, 0); } + public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROW, 0); } + public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ROWS, 0); } + public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SCHEMA, 0); } + public KW_SCHEMAS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SCHEMAS, 0); } + public KW_SECOND(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SECOND, 0); } + public KW_SECONDS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SECONDS, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SET, 0); } + public KW_SHOW(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SHOW, 0); } + public KW_SOME(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SOME, 0); } + public KW_STATS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_STATS, 0); } + public KW_SUBSTRING(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SUBSTRING, 0); } + public KW_SYSTEM(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SYSTEM, 0); } + public KW_TABLES(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TABLES, 0); } + public KW_TABLESAMPLE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TABLESAMPLE, 0); } + public KW_TRUNCATE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TRUNCATE, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TO, 0); } + public KW_TRY_CAST(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TRY_CAST, 0); } + public KW_UNBOUNDED(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_UNBOUNDED, 0); } + public KW_USE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_USE, 0); } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_USER, 0); } + public KW_VIEW(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_VIEW, 0); } + public KW_VIEWS(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_VIEWS, 0); } + public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_YEAR, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_DEFAULT, 0); } + public KW_TEXTFILE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_TEXTFILE, 0); } + public KW_ORC(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_ORC, 0); } + public KW_AVRO(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_AVRO, 0); } + public KW_SEQUENCEFILE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_SEQUENCEFILE, 0); } + public KW_RCFILE(): TerminalNode | undefined { return this.tryGetToken(ImpalaSqlParser.KW_RCFILE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return ImpalaSqlParser.RULE_nonReserved; } + // @Override + public enterRule(listener: ImpalaSqlParserListener): void { + if (listener.enterNonReserved) { + listener.enterNonReserved(this); + } + } + // @Override + public exitRule(listener: ImpalaSqlParserListener): void { + if (listener.exitNonReserved) { + listener.exitNonReserved(this); + } + } + // @Override + public accept(visitor: ImpalaSqlParserVisitor): Result { + if (visitor.visitNonReserved) { + return visitor.visitNonReserved(this); + } else { + return visitor.visitChildren(this); + } + } +} + + diff --git a/src/lib/impala/ImpalaSqlParserListener.ts b/src/lib/impala/ImpalaSqlParserListener.ts new file mode 100644 index 0000000..d49081f --- /dev/null +++ b/src/lib/impala/ImpalaSqlParserListener.ts @@ -0,0 +1,3195 @@ +// Generated from /Users/shuangxu/Documents/workspace/dt-sql-parser/src/grammar/impala/ImpalaSqlParser.g4 by ANTLR 4.9.0-SNAPSHOT + + +import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener"; + +import { JoinRelationContext } from "./ImpalaSqlParser"; +import { RelationDefaultContext } from "./ImpalaSqlParser"; +import { ComparisonContext } from "./ImpalaSqlParser"; +import { QuantifiedComparisonContext } from "./ImpalaSqlParser"; +import { BetweenContext } from "./ImpalaSqlParser"; +import { InListContext } from "./ImpalaSqlParser"; +import { InSubqueryContext } from "./ImpalaSqlParser"; +import { LikeContext } from "./ImpalaSqlParser"; +import { REGEXPContext } from "./ImpalaSqlParser"; +import { NullPredicateContext } from "./ImpalaSqlParser"; +import { DistinctFromContext } from "./ImpalaSqlParser"; +import { DecimalLiteralContext } from "./ImpalaSqlParser"; +import { DoubleLiteralContext } from "./ImpalaSqlParser"; +import { IntegerLiteralContext } from "./ImpalaSqlParser"; +import { QueryTermDefaultContext } from "./ImpalaSqlParser"; +import { SetOperationContext } from "./ImpalaSqlParser"; +import { UnquotedIdentifierContext } from "./ImpalaSqlParser"; +import { QuotedIdentifierContext } from "./ImpalaSqlParser"; +import { BackQuotedIdentifierContext } from "./ImpalaSqlParser"; +import { DigitIdentifierContext } from "./ImpalaSqlParser"; +import { SingleGroupingSetContext } from "./ImpalaSqlParser"; +import { BasicStringLiteralContext } from "./ImpalaSqlParser"; +import { UnicodeStringLiteralContext } from "./ImpalaSqlParser"; +import { ValueExpressionDefaultContext } from "./ImpalaSqlParser"; +import { ArithmeticUnaryContext } from "./ImpalaSqlParser"; +import { ArithmeticBinaryContext } from "./ImpalaSqlParser"; +import { ConcatenationContext } from "./ImpalaSqlParser"; +import { UnboundedFrameContext } from "./ImpalaSqlParser"; +import { CurrentRowBoundContext } from "./ImpalaSqlParser"; +import { BoundedFrameContext } from "./ImpalaSqlParser"; +import { QueryPrimaryDefaultContext } from "./ImpalaSqlParser"; +import { TableContext } from "./ImpalaSqlParser"; +import { InlineTableContext } from "./ImpalaSqlParser"; +import { SubqueryContext } from "./ImpalaSqlParser"; +import { NullLiteralContext } from "./ImpalaSqlParser"; +import { IntervalLiteralContext } from "./ImpalaSqlParser"; +import { TypeConstructorContext } from "./ImpalaSqlParser"; +import { NumericLiteralContext } from "./ImpalaSqlParser"; +import { BooleanLiteralContext } from "./ImpalaSqlParser"; +import { StringLiteralValuesContext } from "./ImpalaSqlParser"; +import { BinaryLiteralContext } from "./ImpalaSqlParser"; +import { ParameterContext } from "./ImpalaSqlParser"; +import { PositionContext } from "./ImpalaSqlParser"; +import { RowConstructorContext } from "./ImpalaSqlParser"; +import { FunctionCallContext } from "./ImpalaSqlParser"; +import { LambdaContext } from "./ImpalaSqlParser"; +import { SubqueryExpressionContext } from "./ImpalaSqlParser"; +import { ExistsContext } from "./ImpalaSqlParser"; +import { SimpleCaseContext } from "./ImpalaSqlParser"; +import { SearchedCaseContext } from "./ImpalaSqlParser"; +import { CastContext } from "./ImpalaSqlParser"; +import { ArrayConstructorContext } from "./ImpalaSqlParser"; +import { SubscriptContext } from "./ImpalaSqlParser"; +import { ColumnReferenceContext } from "./ImpalaSqlParser"; +import { DereferenceContext } from "./ImpalaSqlParser"; +import { SpecialDateTimeFunctionContext } from "./ImpalaSqlParser"; +import { CurrentUserContext } from "./ImpalaSqlParser"; +import { CurrentPathContext } from "./ImpalaSqlParser"; +import { SubstringContext } from "./ImpalaSqlParser"; +import { NormalizeContext } from "./ImpalaSqlParser"; +import { ExtractContext } from "./ImpalaSqlParser"; +import { ParenthesizedExpressionContext } from "./ImpalaSqlParser"; +import { GroupingOperationContext } from "./ImpalaSqlParser"; +import { SelectSingleContext } from "./ImpalaSqlParser"; +import { SelectAllContext } from "./ImpalaSqlParser"; +import { QualifiedArgumentContext } from "./ImpalaSqlParser"; +import { UnqualifiedArgumentContext } from "./ImpalaSqlParser"; +import { RolePrincipalContext } from "./ImpalaSqlParser"; +import { UserPrincipalContext } from "./ImpalaSqlParser"; +import { GroupPrincipalContext } from "./ImpalaSqlParser"; +import { PredicatedContext } from "./ImpalaSqlParser"; +import { LogicalNotContext } from "./ImpalaSqlParser"; +import { LogicalBinaryContext } from "./ImpalaSqlParser"; +import { ProgramContext } from "./ImpalaSqlParser"; +import { StatementContext } from "./ImpalaSqlParser"; +import { UseStatementContext } from "./ImpalaSqlParser"; +import { CreateStatementContext } from "./ImpalaSqlParser"; +import { CreateTableSelectContext } from "./ImpalaSqlParser"; +import { CreateTableLikeContext } from "./ImpalaSqlParser"; +import { CreateKuduTableAsSelectContext } from "./ImpalaSqlParser"; +import { CreateViewContext } from "./ImpalaSqlParser"; +import { CreateSchemaContext } from "./ImpalaSqlParser"; +import { CreateRoleContext } from "./ImpalaSqlParser"; +import { CreateAggregateFunctionContext } from "./ImpalaSqlParser"; +import { CreateFunctionContext } from "./ImpalaSqlParser"; +import { AlterStatementContext } from "./ImpalaSqlParser"; +import { AlterDatabaseContext } from "./ImpalaSqlParser"; +import { AlterStatsKeyContext } from "./ImpalaSqlParser"; +import { AlterPartitionCacheContext } from "./ImpalaSqlParser"; +import { ChangeColumnDefineContext } from "./ImpalaSqlParser"; +import { AlterDropSingleColumnContext } from "./ImpalaSqlParser"; +import { AlterTableOwnerContext } from "./ImpalaSqlParser"; +import { ReplaceOrAddColumnsContext } from "./ImpalaSqlParser"; +import { AddSingleColumnContext } from "./ImpalaSqlParser"; +import { AlterTableNonKuduOrKuduOnlyContext } from "./ImpalaSqlParser"; +import { AddPartitionByRangeOrValueContext } from "./ImpalaSqlParser"; +import { AlterFormatContext } from "./ImpalaSqlParser"; +import { RecoverPartitionsContext } from "./ImpalaSqlParser"; +import { DropPartitionByRangeOrValueContext } from "./ImpalaSqlParser"; +import { AlterViewContext } from "./ImpalaSqlParser"; +import { RenameViewContext } from "./ImpalaSqlParser"; +import { AlterViewOwnerContext } from "./ImpalaSqlParser"; +import { RenameTableContext } from "./ImpalaSqlParser"; +import { AlterUnSetOrSetViewTblpropertiesContext } from "./ImpalaSqlParser"; +import { TruncateTableStatementContext } from "./ImpalaSqlParser"; +import { DescribeStatementContext } from "./ImpalaSqlParser"; +import { ComputeStatementContext } from "./ImpalaSqlParser"; +import { ComputeStatsContext } from "./ImpalaSqlParser"; +import { ComputeIncrementalStatsContext } from "./ImpalaSqlParser"; +import { DropStatementContext } from "./ImpalaSqlParser"; +import { DropSchemaContext } from "./ImpalaSqlParser"; +import { DropViewContext } from "./ImpalaSqlParser"; +import { DropTableContext } from "./ImpalaSqlParser"; +import { DropIncrementalStatsContext } from "./ImpalaSqlParser"; +import { DropFunctionContext } from "./ImpalaSqlParser"; +import { DropRoleContext } from "./ImpalaSqlParser"; +import { GrantStatementContext } from "./ImpalaSqlParser"; +import { GrantRoleContext } from "./ImpalaSqlParser"; +import { GrantContext } from "./ImpalaSqlParser"; +import { RevokeStatementContext } from "./ImpalaSqlParser"; +import { RevokeRoleContext } from "./ImpalaSqlParser"; +import { RevokeContext } from "./ImpalaSqlParser"; +import { InsertStatementContext } from "./ImpalaSqlParser"; +import { DeleteStatementContext } from "./ImpalaSqlParser"; +import { DeleteContext } from "./ImpalaSqlParser"; +import { DeleteTableRefContext } from "./ImpalaSqlParser"; +import { UpdateStatementContext } from "./ImpalaSqlParser"; +import { UpsertStatementContext } from "./ImpalaSqlParser"; +import { ShowStatementContext } from "./ImpalaSqlParser"; +import { ShowSchemasContext } from "./ImpalaSqlParser"; +import { ShowTablesContext } from "./ImpalaSqlParser"; +import { ShowFunctionsContext } from "./ImpalaSqlParser"; +import { ShowCreateTableContext } from "./ImpalaSqlParser"; +import { ShowCreateViewContext } from "./ImpalaSqlParser"; +import { ShowTableStatsContext } from "./ImpalaSqlParser"; +import { ShowColumnStatsContext } from "./ImpalaSqlParser"; +import { ShowPartitionsContext } from "./ImpalaSqlParser"; +import { ShowFilesContext } from "./ImpalaSqlParser"; +import { ShowRolesContext } from "./ImpalaSqlParser"; +import { ShowRoleGrantContext } from "./ImpalaSqlParser"; +import { ShowGrantsContext } from "./ImpalaSqlParser"; +import { ShowDatabaseGrantContext } from "./ImpalaSqlParser"; +import { ShowTableGrantContext } from "./ImpalaSqlParser"; +import { ShowColumnGrantContext } from "./ImpalaSqlParser"; +import { AddCommentStatementContext } from "./ImpalaSqlParser"; +import { AddDatabaseCommentsContext } from "./ImpalaSqlParser"; +import { AddTableCommentsContext } from "./ImpalaSqlParser"; +import { AddColumnCommentsContext } from "./ImpalaSqlParser"; +import { ExplainStatementContext } from "./ImpalaSqlParser"; +import { SetStatementContext } from "./ImpalaSqlParser"; +import { ShutdownStatementContext } from "./ImpalaSqlParser"; +import { InvalidateMetaStatementContext } from "./ImpalaSqlParser"; +import { LoadDataStatementContext } from "./ImpalaSqlParser"; +import { RefreshStatementContext } from "./ImpalaSqlParser"; +import { RefreshMetaContext } from "./ImpalaSqlParser"; +import { RefreshAuthContext } from "./ImpalaSqlParser"; +import { RefreshFunctionContext } from "./ImpalaSqlParser"; +import { IfExistsContext } from "./ImpalaSqlParser"; +import { IfNotExistsContext } from "./ImpalaSqlParser"; +import { TableNameCreateContext } from "./ImpalaSqlParser"; +import { DatabaseNameCreateContext } from "./ImpalaSqlParser"; +import { ViewNameCreateContext } from "./ImpalaSqlParser"; +import { FunctionNameCreateContext } from "./ImpalaSqlParser"; +import { ColumnNamePathCreateContext } from "./ImpalaSqlParser"; +import { DatabaseNamePathContext } from "./ImpalaSqlParser"; +import { TableNamePathContext } from "./ImpalaSqlParser"; +import { ViewNamePathContext } from "./ImpalaSqlParser"; +import { FunctionNamePathContext } from "./ImpalaSqlParser"; +import { ColumnNamePathContext } from "./ImpalaSqlParser"; +import { TableOrViewPathContext } from "./ImpalaSqlParser"; +import { CreateCommonItemContext } from "./ImpalaSqlParser"; +import { AssignmentListContext } from "./ImpalaSqlParser"; +import { AssignmentItemContext } from "./ImpalaSqlParser"; +import { ViewColumnsContext } from "./ImpalaSqlParser"; +import { QueryStatementContext } from "./ImpalaSqlParser"; +import { WithContext } from "./ImpalaSqlParser"; +import { ConstraintSpecificationContext } from "./ImpalaSqlParser"; +import { ForeignKeySpecificationContext } from "./ImpalaSqlParser"; +import { ColumnDefinitionContext } from "./ImpalaSqlParser"; +import { KuduTableElementContext } from "./ImpalaSqlParser"; +import { KuduColumnDefinitionContext } from "./ImpalaSqlParser"; +import { ColumnSpecWithKuduContext } from "./ImpalaSqlParser"; +import { CreateColumnSpecWithKuduContext } from "./ImpalaSqlParser"; +import { KuduAttributesContext } from "./ImpalaSqlParser"; +import { KuduStorageAttrContext } from "./ImpalaSqlParser"; +import { StatsKeyContext } from "./ImpalaSqlParser"; +import { FileFormatContext } from "./ImpalaSqlParser"; +import { KuduPartitionClauseContext } from "./ImpalaSqlParser"; +import { HashClauseContext } from "./ImpalaSqlParser"; +import { RangeClauseContext } from "./ImpalaSqlParser"; +import { KuduPartitionSpecContext } from "./ImpalaSqlParser"; +import { CacheSpecContext } from "./ImpalaSqlParser"; +import { RangeOperatorContext } from "./ImpalaSqlParser"; +import { PartitionColContext } from "./ImpalaSqlParser"; +import { LikeClauseContext } from "./ImpalaSqlParser"; +import { PropertiesContext } from "./ImpalaSqlParser"; +import { PartitionedByContext } from "./ImpalaSqlParser"; +import { SortedByContext } from "./ImpalaSqlParser"; +import { RowFormatContext } from "./ImpalaSqlParser"; +import { PropertyContext } from "./ImpalaSqlParser"; +import { QueryNoWithContext } from "./ImpalaSqlParser"; +import { QueryTermContext } from "./ImpalaSqlParser"; +import { QueryPrimaryContext } from "./ImpalaSqlParser"; +import { SortItemContext } from "./ImpalaSqlParser"; +import { QuerySpecificationContext } from "./ImpalaSqlParser"; +import { GroupByContext } from "./ImpalaSqlParser"; +import { GroupingElementContext } from "./ImpalaSqlParser"; +import { GroupingSetContext } from "./ImpalaSqlParser"; +import { NamedQueryContext } from "./ImpalaSqlParser"; +import { SetQuantifierContext } from "./ImpalaSqlParser"; +import { SelectItemContext } from "./ImpalaSqlParser"; +import { RelationContext } from "./ImpalaSqlParser"; +import { JoinTypeContext } from "./ImpalaSqlParser"; +import { JoinCriteriaContext } from "./ImpalaSqlParser"; +import { SampledRelationContext } from "./ImpalaSqlParser"; +import { SampleTypeContext } from "./ImpalaSqlParser"; +import { AliasedRelationContext } from "./ImpalaSqlParser"; +import { ColumnAliasesContext } from "./ImpalaSqlParser"; +import { CreateColumnAliasesContext } from "./ImpalaSqlParser"; +import { RelationPrimaryContext } from "./ImpalaSqlParser"; +import { SubQueryRelationContext } from "./ImpalaSqlParser"; +import { UnnestContext } from "./ImpalaSqlParser"; +import { ParenthesizedRelationContext } from "./ImpalaSqlParser"; +import { ColumnItemContext } from "./ImpalaSqlParser"; +import { ExpressionContext } from "./ImpalaSqlParser"; +import { BooleanExpressionContext } from "./ImpalaSqlParser"; +import { PredicateContext } from "./ImpalaSqlParser"; +import { ValueExpressionContext } from "./ImpalaSqlParser"; +import { PrimaryExpressionContext } from "./ImpalaSqlParser"; +import { StringLiteralContext } from "./ImpalaSqlParser"; +import { ComparisonOperatorContext } from "./ImpalaSqlParser"; +import { ComparisonQuantifierContext } from "./ImpalaSqlParser"; +import { BooleanValueContext } from "./ImpalaSqlParser"; +import { IntervalContext } from "./ImpalaSqlParser"; +import { IntervalFieldContext } from "./ImpalaSqlParser"; +import { NormalFormContext } from "./ImpalaSqlParser"; +import { TypeContext } from "./ImpalaSqlParser"; +import { TypeParameterContext } from "./ImpalaSqlParser"; +import { BaseTypeContext } from "./ImpalaSqlParser"; +import { WhenClauseContext } from "./ImpalaSqlParser"; +import { FilterContext } from "./ImpalaSqlParser"; +import { OverContext } from "./ImpalaSqlParser"; +import { WindowFrameContext } from "./ImpalaSqlParser"; +import { FrameBoundContext } from "./ImpalaSqlParser"; +import { PathElementContext } from "./ImpalaSqlParser"; +import { PathSpecificationContext } from "./ImpalaSqlParser"; +import { PrivilegeContext } from "./ImpalaSqlParser"; +import { ObjectTypeContext } from "./ImpalaSqlParser"; +import { QualifiedNameContext } from "./ImpalaSqlParser"; +import { PrincipalContext } from "./ImpalaSqlParser"; +import { IdentifierContext } from "./ImpalaSqlParser"; +import { NumberContext } from "./ImpalaSqlParser"; +import { NonReservedContext } from "./ImpalaSqlParser"; + + +/** + * This interface defines a complete listener for a parse tree produced by + * `ImpalaSqlParser`. + */ +export interface ImpalaSqlParserListener extends ParseTreeListener { + /** + * Enter a parse tree produced by the `joinRelation` + * labeled alternative in `ImpalaSqlParser.relation`. + * @param ctx the parse tree + */ + enterJoinRelation?: (ctx: JoinRelationContext) => void; + /** + * Exit a parse tree produced by the `joinRelation` + * labeled alternative in `ImpalaSqlParser.relation`. + * @param ctx the parse tree + */ + exitJoinRelation?: (ctx: JoinRelationContext) => void; + + /** + * Enter a parse tree produced by the `relationDefault` + * labeled alternative in `ImpalaSqlParser.relation`. + * @param ctx the parse tree + */ + enterRelationDefault?: (ctx: RelationDefaultContext) => void; + /** + * Exit a parse tree produced by the `relationDefault` + * labeled alternative in `ImpalaSqlParser.relation`. + * @param ctx the parse tree + */ + exitRelationDefault?: (ctx: RelationDefaultContext) => void; + + /** + * Enter a parse tree produced by the `comparison` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + enterComparison?: (ctx: ComparisonContext) => void; + /** + * Exit a parse tree produced by the `comparison` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + exitComparison?: (ctx: ComparisonContext) => void; + + /** + * Enter a parse tree produced by the `quantifiedComparison` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + enterQuantifiedComparison?: (ctx: QuantifiedComparisonContext) => void; + /** + * Exit a parse tree produced by the `quantifiedComparison` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + exitQuantifiedComparison?: (ctx: QuantifiedComparisonContext) => void; + + /** + * Enter a parse tree produced by the `between` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + enterBetween?: (ctx: BetweenContext) => void; + /** + * Exit a parse tree produced by the `between` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + exitBetween?: (ctx: BetweenContext) => void; + + /** + * Enter a parse tree produced by the `inList` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + enterInList?: (ctx: InListContext) => void; + /** + * Exit a parse tree produced by the `inList` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + exitInList?: (ctx: InListContext) => void; + + /** + * Enter a parse tree produced by the `inSubquery` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + enterInSubquery?: (ctx: InSubqueryContext) => void; + /** + * Exit a parse tree produced by the `inSubquery` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + exitInSubquery?: (ctx: InSubqueryContext) => void; + + /** + * Enter a parse tree produced by the `like` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + enterLike?: (ctx: LikeContext) => void; + /** + * Exit a parse tree produced by the `like` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + exitLike?: (ctx: LikeContext) => void; + + /** + * Enter a parse tree produced by the `REGEXP` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + enterREGEXP?: (ctx: REGEXPContext) => void; + /** + * Exit a parse tree produced by the `REGEXP` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + exitREGEXP?: (ctx: REGEXPContext) => void; + + /** + * Enter a parse tree produced by the `nullPredicate` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + enterNullPredicate?: (ctx: NullPredicateContext) => void; + /** + * Exit a parse tree produced by the `nullPredicate` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + exitNullPredicate?: (ctx: NullPredicateContext) => void; + + /** + * Enter a parse tree produced by the `distinctFrom` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + enterDistinctFrom?: (ctx: DistinctFromContext) => void; + /** + * Exit a parse tree produced by the `distinctFrom` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + exitDistinctFrom?: (ctx: DistinctFromContext) => void; + + /** + * Enter a parse tree produced by the `decimalLiteral` + * labeled alternative in `ImpalaSqlParser.number`. + * @param ctx the parse tree + */ + enterDecimalLiteral?: (ctx: DecimalLiteralContext) => void; + /** + * Exit a parse tree produced by the `decimalLiteral` + * labeled alternative in `ImpalaSqlParser.number`. + * @param ctx the parse tree + */ + exitDecimalLiteral?: (ctx: DecimalLiteralContext) => void; + + /** + * Enter a parse tree produced by the `doubleLiteral` + * labeled alternative in `ImpalaSqlParser.number`. + * @param ctx the parse tree + */ + enterDoubleLiteral?: (ctx: DoubleLiteralContext) => void; + /** + * Exit a parse tree produced by the `doubleLiteral` + * labeled alternative in `ImpalaSqlParser.number`. + * @param ctx the parse tree + */ + exitDoubleLiteral?: (ctx: DoubleLiteralContext) => void; + + /** + * Enter a parse tree produced by the `integerLiteral` + * labeled alternative in `ImpalaSqlParser.number`. + * @param ctx the parse tree + */ + enterIntegerLiteral?: (ctx: IntegerLiteralContext) => void; + /** + * Exit a parse tree produced by the `integerLiteral` + * labeled alternative in `ImpalaSqlParser.number`. + * @param ctx the parse tree + */ + exitIntegerLiteral?: (ctx: IntegerLiteralContext) => void; + + /** + * Enter a parse tree produced by the `queryTermDefault` + * labeled alternative in `ImpalaSqlParser.queryTerm`. + * @param ctx the parse tree + */ + enterQueryTermDefault?: (ctx: QueryTermDefaultContext) => void; + /** + * Exit a parse tree produced by the `queryTermDefault` + * labeled alternative in `ImpalaSqlParser.queryTerm`. + * @param ctx the parse tree + */ + exitQueryTermDefault?: (ctx: QueryTermDefaultContext) => void; + + /** + * Enter a parse tree produced by the `setOperation` + * labeled alternative in `ImpalaSqlParser.queryTerm`. + * @param ctx the parse tree + */ + enterSetOperation?: (ctx: SetOperationContext) => void; + /** + * Exit a parse tree produced by the `setOperation` + * labeled alternative in `ImpalaSqlParser.queryTerm`. + * @param ctx the parse tree + */ + exitSetOperation?: (ctx: SetOperationContext) => void; + + /** + * Enter a parse tree produced by the `unquotedIdentifier` + * labeled alternative in `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + */ + enterUnquotedIdentifier?: (ctx: UnquotedIdentifierContext) => void; + /** + * Exit a parse tree produced by the `unquotedIdentifier` + * labeled alternative in `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + */ + exitUnquotedIdentifier?: (ctx: UnquotedIdentifierContext) => void; + + /** + * Enter a parse tree produced by the `quotedIdentifier` + * labeled alternative in `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + */ + enterQuotedIdentifier?: (ctx: QuotedIdentifierContext) => void; + /** + * Exit a parse tree produced by the `quotedIdentifier` + * labeled alternative in `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + */ + exitQuotedIdentifier?: (ctx: QuotedIdentifierContext) => void; + + /** + * Enter a parse tree produced by the `backQuotedIdentifier` + * labeled alternative in `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + */ + enterBackQuotedIdentifier?: (ctx: BackQuotedIdentifierContext) => void; + /** + * Exit a parse tree produced by the `backQuotedIdentifier` + * labeled alternative in `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + */ + exitBackQuotedIdentifier?: (ctx: BackQuotedIdentifierContext) => void; + + /** + * Enter a parse tree produced by the `digitIdentifier` + * labeled alternative in `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + */ + enterDigitIdentifier?: (ctx: DigitIdentifierContext) => void; + /** + * Exit a parse tree produced by the `digitIdentifier` + * labeled alternative in `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + */ + exitDigitIdentifier?: (ctx: DigitIdentifierContext) => void; + + /** + * Enter a parse tree produced by the `singleGroupingSet` + * labeled alternative in `ImpalaSqlParser.groupingElement`. + * @param ctx the parse tree + */ + enterSingleGroupingSet?: (ctx: SingleGroupingSetContext) => void; + /** + * Exit a parse tree produced by the `singleGroupingSet` + * labeled alternative in `ImpalaSqlParser.groupingElement`. + * @param ctx the parse tree + */ + exitSingleGroupingSet?: (ctx: SingleGroupingSetContext) => void; + + /** + * Enter a parse tree produced by the `basicStringLiteral` + * labeled alternative in `ImpalaSqlParser.stringLiteral`. + * @param ctx the parse tree + */ + enterBasicStringLiteral?: (ctx: BasicStringLiteralContext) => void; + /** + * Exit a parse tree produced by the `basicStringLiteral` + * labeled alternative in `ImpalaSqlParser.stringLiteral`. + * @param ctx the parse tree + */ + exitBasicStringLiteral?: (ctx: BasicStringLiteralContext) => void; + + /** + * Enter a parse tree produced by the `unicodeStringLiteral` + * labeled alternative in `ImpalaSqlParser.stringLiteral`. + * @param ctx the parse tree + */ + enterUnicodeStringLiteral?: (ctx: UnicodeStringLiteralContext) => void; + /** + * Exit a parse tree produced by the `unicodeStringLiteral` + * labeled alternative in `ImpalaSqlParser.stringLiteral`. + * @param ctx the parse tree + */ + exitUnicodeStringLiteral?: (ctx: UnicodeStringLiteralContext) => void; + + /** + * Enter a parse tree produced by the `valueExpressionDefault` + * labeled alternative in `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + */ + enterValueExpressionDefault?: (ctx: ValueExpressionDefaultContext) => void; + /** + * Exit a parse tree produced by the `valueExpressionDefault` + * labeled alternative in `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + */ + exitValueExpressionDefault?: (ctx: ValueExpressionDefaultContext) => void; + + /** + * Enter a parse tree produced by the `arithmeticUnary` + * labeled alternative in `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + */ + enterArithmeticUnary?: (ctx: ArithmeticUnaryContext) => void; + /** + * Exit a parse tree produced by the `arithmeticUnary` + * labeled alternative in `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + */ + exitArithmeticUnary?: (ctx: ArithmeticUnaryContext) => void; + + /** + * Enter a parse tree produced by the `arithmeticBinary` + * labeled alternative in `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + */ + enterArithmeticBinary?: (ctx: ArithmeticBinaryContext) => void; + /** + * Exit a parse tree produced by the `arithmeticBinary` + * labeled alternative in `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + */ + exitArithmeticBinary?: (ctx: ArithmeticBinaryContext) => void; + + /** + * Enter a parse tree produced by the `concatenation` + * labeled alternative in `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + */ + enterConcatenation?: (ctx: ConcatenationContext) => void; + /** + * Exit a parse tree produced by the `concatenation` + * labeled alternative in `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + */ + exitConcatenation?: (ctx: ConcatenationContext) => void; + + /** + * Enter a parse tree produced by the `unboundedFrame` + * labeled alternative in `ImpalaSqlParser.frameBound`. + * @param ctx the parse tree + */ + enterUnboundedFrame?: (ctx: UnboundedFrameContext) => void; + /** + * Exit a parse tree produced by the `unboundedFrame` + * labeled alternative in `ImpalaSqlParser.frameBound`. + * @param ctx the parse tree + */ + exitUnboundedFrame?: (ctx: UnboundedFrameContext) => void; + + /** + * Enter a parse tree produced by the `currentRowBound` + * labeled alternative in `ImpalaSqlParser.frameBound`. + * @param ctx the parse tree + */ + enterCurrentRowBound?: (ctx: CurrentRowBoundContext) => void; + /** + * Exit a parse tree produced by the `currentRowBound` + * labeled alternative in `ImpalaSqlParser.frameBound`. + * @param ctx the parse tree + */ + exitCurrentRowBound?: (ctx: CurrentRowBoundContext) => void; + + /** + * Enter a parse tree produced by the `boundedFrame` + * labeled alternative in `ImpalaSqlParser.frameBound`. + * @param ctx the parse tree + */ + enterBoundedFrame?: (ctx: BoundedFrameContext) => void; + /** + * Exit a parse tree produced by the `boundedFrame` + * labeled alternative in `ImpalaSqlParser.frameBound`. + * @param ctx the parse tree + */ + exitBoundedFrame?: (ctx: BoundedFrameContext) => void; + + /** + * Enter a parse tree produced by the `queryPrimaryDefault` + * labeled alternative in `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + */ + enterQueryPrimaryDefault?: (ctx: QueryPrimaryDefaultContext) => void; + /** + * Exit a parse tree produced by the `queryPrimaryDefault` + * labeled alternative in `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + */ + exitQueryPrimaryDefault?: (ctx: QueryPrimaryDefaultContext) => void; + + /** + * Enter a parse tree produced by the `table` + * labeled alternative in `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + */ + enterTable?: (ctx: TableContext) => void; + /** + * Exit a parse tree produced by the `table` + * labeled alternative in `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + */ + exitTable?: (ctx: TableContext) => void; + + /** + * Enter a parse tree produced by the `inlineTable` + * labeled alternative in `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + */ + enterInlineTable?: (ctx: InlineTableContext) => void; + /** + * Exit a parse tree produced by the `inlineTable` + * labeled alternative in `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + */ + exitInlineTable?: (ctx: InlineTableContext) => void; + + /** + * Enter a parse tree produced by the `subquery` + * labeled alternative in `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + */ + enterSubquery?: (ctx: SubqueryContext) => void; + /** + * Exit a parse tree produced by the `subquery` + * labeled alternative in `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + */ + exitSubquery?: (ctx: SubqueryContext) => void; + + /** + * Enter a parse tree produced by the `nullLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterNullLiteral?: (ctx: NullLiteralContext) => void; + /** + * Exit a parse tree produced by the `nullLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitNullLiteral?: (ctx: NullLiteralContext) => void; + + /** + * Enter a parse tree produced by the `intervalLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterIntervalLiteral?: (ctx: IntervalLiteralContext) => void; + /** + * Exit a parse tree produced by the `intervalLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitIntervalLiteral?: (ctx: IntervalLiteralContext) => void; + + /** + * Enter a parse tree produced by the `typeConstructor` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterTypeConstructor?: (ctx: TypeConstructorContext) => void; + /** + * Exit a parse tree produced by the `typeConstructor` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitTypeConstructor?: (ctx: TypeConstructorContext) => void; + + /** + * Enter a parse tree produced by the `numericLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterNumericLiteral?: (ctx: NumericLiteralContext) => void; + /** + * Exit a parse tree produced by the `numericLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitNumericLiteral?: (ctx: NumericLiteralContext) => void; + + /** + * Enter a parse tree produced by the `booleanLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterBooleanLiteral?: (ctx: BooleanLiteralContext) => void; + /** + * Exit a parse tree produced by the `booleanLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitBooleanLiteral?: (ctx: BooleanLiteralContext) => void; + + /** + * Enter a parse tree produced by the `stringLiteralValues` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterStringLiteralValues?: (ctx: StringLiteralValuesContext) => void; + /** + * Exit a parse tree produced by the `stringLiteralValues` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitStringLiteralValues?: (ctx: StringLiteralValuesContext) => void; + + /** + * Enter a parse tree produced by the `binaryLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterBinaryLiteral?: (ctx: BinaryLiteralContext) => void; + /** + * Exit a parse tree produced by the `binaryLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitBinaryLiteral?: (ctx: BinaryLiteralContext) => void; + + /** + * Enter a parse tree produced by the `parameter` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterParameter?: (ctx: ParameterContext) => void; + /** + * Exit a parse tree produced by the `parameter` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitParameter?: (ctx: ParameterContext) => void; + + /** + * Enter a parse tree produced by the `position` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterPosition?: (ctx: PositionContext) => void; + /** + * Exit a parse tree produced by the `position` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitPosition?: (ctx: PositionContext) => void; + + /** + * Enter a parse tree produced by the `rowConstructor` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterRowConstructor?: (ctx: RowConstructorContext) => void; + /** + * Exit a parse tree produced by the `rowConstructor` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitRowConstructor?: (ctx: RowConstructorContext) => void; + + /** + * Enter a parse tree produced by the `functionCall` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterFunctionCall?: (ctx: FunctionCallContext) => void; + /** + * Exit a parse tree produced by the `functionCall` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitFunctionCall?: (ctx: FunctionCallContext) => void; + + /** + * Enter a parse tree produced by the `lambda` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterLambda?: (ctx: LambdaContext) => void; + /** + * Exit a parse tree produced by the `lambda` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitLambda?: (ctx: LambdaContext) => void; + + /** + * Enter a parse tree produced by the `subqueryExpression` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterSubqueryExpression?: (ctx: SubqueryExpressionContext) => void; + /** + * Exit a parse tree produced by the `subqueryExpression` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitSubqueryExpression?: (ctx: SubqueryExpressionContext) => void; + + /** + * Enter a parse tree produced by the `exists` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterExists?: (ctx: ExistsContext) => void; + /** + * Exit a parse tree produced by the `exists` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitExists?: (ctx: ExistsContext) => void; + + /** + * Enter a parse tree produced by the `simpleCase` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterSimpleCase?: (ctx: SimpleCaseContext) => void; + /** + * Exit a parse tree produced by the `simpleCase` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitSimpleCase?: (ctx: SimpleCaseContext) => void; + + /** + * Enter a parse tree produced by the `searchedCase` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterSearchedCase?: (ctx: SearchedCaseContext) => void; + /** + * Exit a parse tree produced by the `searchedCase` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitSearchedCase?: (ctx: SearchedCaseContext) => void; + + /** + * Enter a parse tree produced by the `cast` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterCast?: (ctx: CastContext) => void; + /** + * Exit a parse tree produced by the `cast` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitCast?: (ctx: CastContext) => void; + + /** + * Enter a parse tree produced by the `arrayConstructor` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterArrayConstructor?: (ctx: ArrayConstructorContext) => void; + /** + * Exit a parse tree produced by the `arrayConstructor` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitArrayConstructor?: (ctx: ArrayConstructorContext) => void; + + /** + * Enter a parse tree produced by the `subscript` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterSubscript?: (ctx: SubscriptContext) => void; + /** + * Exit a parse tree produced by the `subscript` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitSubscript?: (ctx: SubscriptContext) => void; + + /** + * Enter a parse tree produced by the `columnReference` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterColumnReference?: (ctx: ColumnReferenceContext) => void; + /** + * Exit a parse tree produced by the `columnReference` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitColumnReference?: (ctx: ColumnReferenceContext) => void; + + /** + * Enter a parse tree produced by the `dereference` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterDereference?: (ctx: DereferenceContext) => void; + /** + * Exit a parse tree produced by the `dereference` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitDereference?: (ctx: DereferenceContext) => void; + + /** + * Enter a parse tree produced by the `specialDateTimeFunction` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterSpecialDateTimeFunction?: (ctx: SpecialDateTimeFunctionContext) => void; + /** + * Exit a parse tree produced by the `specialDateTimeFunction` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitSpecialDateTimeFunction?: (ctx: SpecialDateTimeFunctionContext) => void; + + /** + * Enter a parse tree produced by the `currentUser` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterCurrentUser?: (ctx: CurrentUserContext) => void; + /** + * Exit a parse tree produced by the `currentUser` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitCurrentUser?: (ctx: CurrentUserContext) => void; + + /** + * Enter a parse tree produced by the `currentPath` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterCurrentPath?: (ctx: CurrentPathContext) => void; + /** + * Exit a parse tree produced by the `currentPath` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitCurrentPath?: (ctx: CurrentPathContext) => void; + + /** + * Enter a parse tree produced by the `substring` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterSubstring?: (ctx: SubstringContext) => void; + /** + * Exit a parse tree produced by the `substring` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitSubstring?: (ctx: SubstringContext) => void; + + /** + * Enter a parse tree produced by the `normalize` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterNormalize?: (ctx: NormalizeContext) => void; + /** + * Exit a parse tree produced by the `normalize` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitNormalize?: (ctx: NormalizeContext) => void; + + /** + * Enter a parse tree produced by the `extract` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterExtract?: (ctx: ExtractContext) => void; + /** + * Exit a parse tree produced by the `extract` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitExtract?: (ctx: ExtractContext) => void; + + /** + * Enter a parse tree produced by the `parenthesizedExpression` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterParenthesizedExpression?: (ctx: ParenthesizedExpressionContext) => void; + /** + * Exit a parse tree produced by the `parenthesizedExpression` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitParenthesizedExpression?: (ctx: ParenthesizedExpressionContext) => void; + + /** + * Enter a parse tree produced by the `groupingOperation` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterGroupingOperation?: (ctx: GroupingOperationContext) => void; + /** + * Exit a parse tree produced by the `groupingOperation` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitGroupingOperation?: (ctx: GroupingOperationContext) => void; + + /** + * Enter a parse tree produced by the `selectSingle` + * labeled alternative in `ImpalaSqlParser.selectItem`. + * @param ctx the parse tree + */ + enterSelectSingle?: (ctx: SelectSingleContext) => void; + /** + * Exit a parse tree produced by the `selectSingle` + * labeled alternative in `ImpalaSqlParser.selectItem`. + * @param ctx the parse tree + */ + exitSelectSingle?: (ctx: SelectSingleContext) => void; + + /** + * Enter a parse tree produced by the `selectAll` + * labeled alternative in `ImpalaSqlParser.selectItem`. + * @param ctx the parse tree + */ + enterSelectAll?: (ctx: SelectAllContext) => void; + /** + * Exit a parse tree produced by the `selectAll` + * labeled alternative in `ImpalaSqlParser.selectItem`. + * @param ctx the parse tree + */ + exitSelectAll?: (ctx: SelectAllContext) => void; + + /** + * Enter a parse tree produced by the `qualifiedArgument` + * labeled alternative in `ImpalaSqlParser.pathElement`. + * @param ctx the parse tree + */ + enterQualifiedArgument?: (ctx: QualifiedArgumentContext) => void; + /** + * Exit a parse tree produced by the `qualifiedArgument` + * labeled alternative in `ImpalaSqlParser.pathElement`. + * @param ctx the parse tree + */ + exitQualifiedArgument?: (ctx: QualifiedArgumentContext) => void; + + /** + * Enter a parse tree produced by the `unqualifiedArgument` + * labeled alternative in `ImpalaSqlParser.pathElement`. + * @param ctx the parse tree + */ + enterUnqualifiedArgument?: (ctx: UnqualifiedArgumentContext) => void; + /** + * Exit a parse tree produced by the `unqualifiedArgument` + * labeled alternative in `ImpalaSqlParser.pathElement`. + * @param ctx the parse tree + */ + exitUnqualifiedArgument?: (ctx: UnqualifiedArgumentContext) => void; + + /** + * Enter a parse tree produced by the `rolePrincipal` + * labeled alternative in `ImpalaSqlParser.principal`. + * @param ctx the parse tree + */ + enterRolePrincipal?: (ctx: RolePrincipalContext) => void; + /** + * Exit a parse tree produced by the `rolePrincipal` + * labeled alternative in `ImpalaSqlParser.principal`. + * @param ctx the parse tree + */ + exitRolePrincipal?: (ctx: RolePrincipalContext) => void; + + /** + * Enter a parse tree produced by the `userPrincipal` + * labeled alternative in `ImpalaSqlParser.principal`. + * @param ctx the parse tree + */ + enterUserPrincipal?: (ctx: UserPrincipalContext) => void; + /** + * Exit a parse tree produced by the `userPrincipal` + * labeled alternative in `ImpalaSqlParser.principal`. + * @param ctx the parse tree + */ + exitUserPrincipal?: (ctx: UserPrincipalContext) => void; + + /** + * Enter a parse tree produced by the `groupPrincipal` + * labeled alternative in `ImpalaSqlParser.principal`. + * @param ctx the parse tree + */ + enterGroupPrincipal?: (ctx: GroupPrincipalContext) => void; + /** + * Exit a parse tree produced by the `groupPrincipal` + * labeled alternative in `ImpalaSqlParser.principal`. + * @param ctx the parse tree + */ + exitGroupPrincipal?: (ctx: GroupPrincipalContext) => void; + + /** + * Enter a parse tree produced by the `predicated` + * labeled alternative in `ImpalaSqlParser.booleanExpression`. + * @param ctx the parse tree + */ + enterPredicated?: (ctx: PredicatedContext) => void; + /** + * Exit a parse tree produced by the `predicated` + * labeled alternative in `ImpalaSqlParser.booleanExpression`. + * @param ctx the parse tree + */ + exitPredicated?: (ctx: PredicatedContext) => void; + + /** + * Enter a parse tree produced by the `logicalNot` + * labeled alternative in `ImpalaSqlParser.booleanExpression`. + * @param ctx the parse tree + */ + enterLogicalNot?: (ctx: LogicalNotContext) => void; + /** + * Exit a parse tree produced by the `logicalNot` + * labeled alternative in `ImpalaSqlParser.booleanExpression`. + * @param ctx the parse tree + */ + exitLogicalNot?: (ctx: LogicalNotContext) => void; + + /** + * Enter a parse tree produced by the `logicalBinary` + * labeled alternative in `ImpalaSqlParser.booleanExpression`. + * @param ctx the parse tree + */ + enterLogicalBinary?: (ctx: LogicalBinaryContext) => void; + /** + * Exit a parse tree produced by the `logicalBinary` + * labeled alternative in `ImpalaSqlParser.booleanExpression`. + * @param ctx the parse tree + */ + exitLogicalBinary?: (ctx: LogicalBinaryContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.program`. + * @param ctx the parse tree + */ + enterProgram?: (ctx: ProgramContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.program`. + * @param ctx the parse tree + */ + exitProgram?: (ctx: ProgramContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.statement`. + * @param ctx the parse tree + */ + enterStatement?: (ctx: StatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.statement`. + * @param ctx the parse tree + */ + exitStatement?: (ctx: StatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.useStatement`. + * @param ctx the parse tree + */ + enterUseStatement?: (ctx: UseStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.useStatement`. + * @param ctx the parse tree + */ + exitUseStatement?: (ctx: UseStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.createStatement`. + * @param ctx the parse tree + */ + enterCreateStatement?: (ctx: CreateStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.createStatement`. + * @param ctx the parse tree + */ + exitCreateStatement?: (ctx: CreateStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.createTableSelect`. + * @param ctx the parse tree + */ + enterCreateTableSelect?: (ctx: CreateTableSelectContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.createTableSelect`. + * @param ctx the parse tree + */ + exitCreateTableSelect?: (ctx: CreateTableSelectContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.createTableLike`. + * @param ctx the parse tree + */ + enterCreateTableLike?: (ctx: CreateTableLikeContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.createTableLike`. + * @param ctx the parse tree + */ + exitCreateTableLike?: (ctx: CreateTableLikeContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.createKuduTableAsSelect`. + * @param ctx the parse tree + */ + enterCreateKuduTableAsSelect?: (ctx: CreateKuduTableAsSelectContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.createKuduTableAsSelect`. + * @param ctx the parse tree + */ + exitCreateKuduTableAsSelect?: (ctx: CreateKuduTableAsSelectContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.createView`. + * @param ctx the parse tree + */ + enterCreateView?: (ctx: CreateViewContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.createView`. + * @param ctx the parse tree + */ + exitCreateView?: (ctx: CreateViewContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.createSchema`. + * @param ctx the parse tree + */ + enterCreateSchema?: (ctx: CreateSchemaContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.createSchema`. + * @param ctx the parse tree + */ + exitCreateSchema?: (ctx: CreateSchemaContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.createRole`. + * @param ctx the parse tree + */ + enterCreateRole?: (ctx: CreateRoleContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.createRole`. + * @param ctx the parse tree + */ + exitCreateRole?: (ctx: CreateRoleContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.createAggregateFunction`. + * @param ctx the parse tree + */ + enterCreateAggregateFunction?: (ctx: CreateAggregateFunctionContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.createAggregateFunction`. + * @param ctx the parse tree + */ + exitCreateAggregateFunction?: (ctx: CreateAggregateFunctionContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.createFunction`. + * @param ctx the parse tree + */ + enterCreateFunction?: (ctx: CreateFunctionContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.createFunction`. + * @param ctx the parse tree + */ + exitCreateFunction?: (ctx: CreateFunctionContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.alterStatement`. + * @param ctx the parse tree + */ + enterAlterStatement?: (ctx: AlterStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.alterStatement`. + * @param ctx the parse tree + */ + exitAlterStatement?: (ctx: AlterStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.alterDatabase`. + * @param ctx the parse tree + */ + enterAlterDatabase?: (ctx: AlterDatabaseContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.alterDatabase`. + * @param ctx the parse tree + */ + exitAlterDatabase?: (ctx: AlterDatabaseContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.alterStatsKey`. + * @param ctx the parse tree + */ + enterAlterStatsKey?: (ctx: AlterStatsKeyContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.alterStatsKey`. + * @param ctx the parse tree + */ + exitAlterStatsKey?: (ctx: AlterStatsKeyContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.alterPartitionCache`. + * @param ctx the parse tree + */ + enterAlterPartitionCache?: (ctx: AlterPartitionCacheContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.alterPartitionCache`. + * @param ctx the parse tree + */ + exitAlterPartitionCache?: (ctx: AlterPartitionCacheContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.changeColumnDefine`. + * @param ctx the parse tree + */ + enterChangeColumnDefine?: (ctx: ChangeColumnDefineContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.changeColumnDefine`. + * @param ctx the parse tree + */ + exitChangeColumnDefine?: (ctx: ChangeColumnDefineContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.alterDropSingleColumn`. + * @param ctx the parse tree + */ + enterAlterDropSingleColumn?: (ctx: AlterDropSingleColumnContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.alterDropSingleColumn`. + * @param ctx the parse tree + */ + exitAlterDropSingleColumn?: (ctx: AlterDropSingleColumnContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.alterTableOwner`. + * @param ctx the parse tree + */ + enterAlterTableOwner?: (ctx: AlterTableOwnerContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.alterTableOwner`. + * @param ctx the parse tree + */ + exitAlterTableOwner?: (ctx: AlterTableOwnerContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.replaceOrAddColumns`. + * @param ctx the parse tree + */ + enterReplaceOrAddColumns?: (ctx: ReplaceOrAddColumnsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.replaceOrAddColumns`. + * @param ctx the parse tree + */ + exitReplaceOrAddColumns?: (ctx: ReplaceOrAddColumnsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.addSingleColumn`. + * @param ctx the parse tree + */ + enterAddSingleColumn?: (ctx: AddSingleColumnContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.addSingleColumn`. + * @param ctx the parse tree + */ + exitAddSingleColumn?: (ctx: AddSingleColumnContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.alterTableNonKuduOrKuduOnly`. + * @param ctx the parse tree + */ + enterAlterTableNonKuduOrKuduOnly?: (ctx: AlterTableNonKuduOrKuduOnlyContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.alterTableNonKuduOrKuduOnly`. + * @param ctx the parse tree + */ + exitAlterTableNonKuduOrKuduOnly?: (ctx: AlterTableNonKuduOrKuduOnlyContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.addPartitionByRangeOrValue`. + * @param ctx the parse tree + */ + enterAddPartitionByRangeOrValue?: (ctx: AddPartitionByRangeOrValueContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.addPartitionByRangeOrValue`. + * @param ctx the parse tree + */ + exitAddPartitionByRangeOrValue?: (ctx: AddPartitionByRangeOrValueContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.alterFormat`. + * @param ctx the parse tree + */ + enterAlterFormat?: (ctx: AlterFormatContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.alterFormat`. + * @param ctx the parse tree + */ + exitAlterFormat?: (ctx: AlterFormatContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.recoverPartitions`. + * @param ctx the parse tree + */ + enterRecoverPartitions?: (ctx: RecoverPartitionsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.recoverPartitions`. + * @param ctx the parse tree + */ + exitRecoverPartitions?: (ctx: RecoverPartitionsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.dropPartitionByRangeOrValue`. + * @param ctx the parse tree + */ + enterDropPartitionByRangeOrValue?: (ctx: DropPartitionByRangeOrValueContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.dropPartitionByRangeOrValue`. + * @param ctx the parse tree + */ + exitDropPartitionByRangeOrValue?: (ctx: DropPartitionByRangeOrValueContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.alterView`. + * @param ctx the parse tree + */ + enterAlterView?: (ctx: AlterViewContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.alterView`. + * @param ctx the parse tree + */ + exitAlterView?: (ctx: AlterViewContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.renameView`. + * @param ctx the parse tree + */ + enterRenameView?: (ctx: RenameViewContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.renameView`. + * @param ctx the parse tree + */ + exitRenameView?: (ctx: RenameViewContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.alterViewOwner`. + * @param ctx the parse tree + */ + enterAlterViewOwner?: (ctx: AlterViewOwnerContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.alterViewOwner`. + * @param ctx the parse tree + */ + exitAlterViewOwner?: (ctx: AlterViewOwnerContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.renameTable`. + * @param ctx the parse tree + */ + enterRenameTable?: (ctx: RenameTableContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.renameTable`. + * @param ctx the parse tree + */ + exitRenameTable?: (ctx: RenameTableContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.alterUnSetOrSetViewTblproperties`. + * @param ctx the parse tree + */ + enterAlterUnSetOrSetViewTblproperties?: (ctx: AlterUnSetOrSetViewTblpropertiesContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.alterUnSetOrSetViewTblproperties`. + * @param ctx the parse tree + */ + exitAlterUnSetOrSetViewTblproperties?: (ctx: AlterUnSetOrSetViewTblpropertiesContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.truncateTableStatement`. + * @param ctx the parse tree + */ + enterTruncateTableStatement?: (ctx: TruncateTableStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.truncateTableStatement`. + * @param ctx the parse tree + */ + exitTruncateTableStatement?: (ctx: TruncateTableStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.describeStatement`. + * @param ctx the parse tree + */ + enterDescribeStatement?: (ctx: DescribeStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.describeStatement`. + * @param ctx the parse tree + */ + exitDescribeStatement?: (ctx: DescribeStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.computeStatement`. + * @param ctx the parse tree + */ + enterComputeStatement?: (ctx: ComputeStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.computeStatement`. + * @param ctx the parse tree + */ + exitComputeStatement?: (ctx: ComputeStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.computeStats`. + * @param ctx the parse tree + */ + enterComputeStats?: (ctx: ComputeStatsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.computeStats`. + * @param ctx the parse tree + */ + exitComputeStats?: (ctx: ComputeStatsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.computeIncrementalStats`. + * @param ctx the parse tree + */ + enterComputeIncrementalStats?: (ctx: ComputeIncrementalStatsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.computeIncrementalStats`. + * @param ctx the parse tree + */ + exitComputeIncrementalStats?: (ctx: ComputeIncrementalStatsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.dropStatement`. + * @param ctx the parse tree + */ + enterDropStatement?: (ctx: DropStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.dropStatement`. + * @param ctx the parse tree + */ + exitDropStatement?: (ctx: DropStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.dropSchema`. + * @param ctx the parse tree + */ + enterDropSchema?: (ctx: DropSchemaContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.dropSchema`. + * @param ctx the parse tree + */ + exitDropSchema?: (ctx: DropSchemaContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.dropView`. + * @param ctx the parse tree + */ + enterDropView?: (ctx: DropViewContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.dropView`. + * @param ctx the parse tree + */ + exitDropView?: (ctx: DropViewContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.dropTable`. + * @param ctx the parse tree + */ + enterDropTable?: (ctx: DropTableContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.dropTable`. + * @param ctx the parse tree + */ + exitDropTable?: (ctx: DropTableContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.dropIncrementalStats`. + * @param ctx the parse tree + */ + enterDropIncrementalStats?: (ctx: DropIncrementalStatsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.dropIncrementalStats`. + * @param ctx the parse tree + */ + exitDropIncrementalStats?: (ctx: DropIncrementalStatsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.dropFunction`. + * @param ctx the parse tree + */ + enterDropFunction?: (ctx: DropFunctionContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.dropFunction`. + * @param ctx the parse tree + */ + exitDropFunction?: (ctx: DropFunctionContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.dropRole`. + * @param ctx the parse tree + */ + enterDropRole?: (ctx: DropRoleContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.dropRole`. + * @param ctx the parse tree + */ + exitDropRole?: (ctx: DropRoleContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.grantStatement`. + * @param ctx the parse tree + */ + enterGrantStatement?: (ctx: GrantStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.grantStatement`. + * @param ctx the parse tree + */ + exitGrantStatement?: (ctx: GrantStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.grantRole`. + * @param ctx the parse tree + */ + enterGrantRole?: (ctx: GrantRoleContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.grantRole`. + * @param ctx the parse tree + */ + exitGrantRole?: (ctx: GrantRoleContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.grant`. + * @param ctx the parse tree + */ + enterGrant?: (ctx: GrantContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.grant`. + * @param ctx the parse tree + */ + exitGrant?: (ctx: GrantContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.revokeStatement`. + * @param ctx the parse tree + */ + enterRevokeStatement?: (ctx: RevokeStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.revokeStatement`. + * @param ctx the parse tree + */ + exitRevokeStatement?: (ctx: RevokeStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.revokeRole`. + * @param ctx the parse tree + */ + enterRevokeRole?: (ctx: RevokeRoleContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.revokeRole`. + * @param ctx the parse tree + */ + exitRevokeRole?: (ctx: RevokeRoleContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.revoke`. + * @param ctx the parse tree + */ + enterRevoke?: (ctx: RevokeContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.revoke`. + * @param ctx the parse tree + */ + exitRevoke?: (ctx: RevokeContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.insertStatement`. + * @param ctx the parse tree + */ + enterInsertStatement?: (ctx: InsertStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.insertStatement`. + * @param ctx the parse tree + */ + exitInsertStatement?: (ctx: InsertStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.deleteStatement`. + * @param ctx the parse tree + */ + enterDeleteStatement?: (ctx: DeleteStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.deleteStatement`. + * @param ctx the parse tree + */ + exitDeleteStatement?: (ctx: DeleteStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.delete`. + * @param ctx the parse tree + */ + enterDelete?: (ctx: DeleteContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.delete`. + * @param ctx the parse tree + */ + exitDelete?: (ctx: DeleteContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.deleteTableRef`. + * @param ctx the parse tree + */ + enterDeleteTableRef?: (ctx: DeleteTableRefContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.deleteTableRef`. + * @param ctx the parse tree + */ + exitDeleteTableRef?: (ctx: DeleteTableRefContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.updateStatement`. + * @param ctx the parse tree + */ + enterUpdateStatement?: (ctx: UpdateStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.updateStatement`. + * @param ctx the parse tree + */ + exitUpdateStatement?: (ctx: UpdateStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.upsertStatement`. + * @param ctx the parse tree + */ + enterUpsertStatement?: (ctx: UpsertStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.upsertStatement`. + * @param ctx the parse tree + */ + exitUpsertStatement?: (ctx: UpsertStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showStatement`. + * @param ctx the parse tree + */ + enterShowStatement?: (ctx: ShowStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showStatement`. + * @param ctx the parse tree + */ + exitShowStatement?: (ctx: ShowStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showSchemas`. + * @param ctx the parse tree + */ + enterShowSchemas?: (ctx: ShowSchemasContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showSchemas`. + * @param ctx the parse tree + */ + exitShowSchemas?: (ctx: ShowSchemasContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showTables`. + * @param ctx the parse tree + */ + enterShowTables?: (ctx: ShowTablesContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showTables`. + * @param ctx the parse tree + */ + exitShowTables?: (ctx: ShowTablesContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showFunctions`. + * @param ctx the parse tree + */ + enterShowFunctions?: (ctx: ShowFunctionsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showFunctions`. + * @param ctx the parse tree + */ + exitShowFunctions?: (ctx: ShowFunctionsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showCreateTable`. + * @param ctx the parse tree + */ + enterShowCreateTable?: (ctx: ShowCreateTableContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showCreateTable`. + * @param ctx the parse tree + */ + exitShowCreateTable?: (ctx: ShowCreateTableContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showCreateView`. + * @param ctx the parse tree + */ + enterShowCreateView?: (ctx: ShowCreateViewContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showCreateView`. + * @param ctx the parse tree + */ + exitShowCreateView?: (ctx: ShowCreateViewContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showTableStats`. + * @param ctx the parse tree + */ + enterShowTableStats?: (ctx: ShowTableStatsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showTableStats`. + * @param ctx the parse tree + */ + exitShowTableStats?: (ctx: ShowTableStatsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showColumnStats`. + * @param ctx the parse tree + */ + enterShowColumnStats?: (ctx: ShowColumnStatsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showColumnStats`. + * @param ctx the parse tree + */ + exitShowColumnStats?: (ctx: ShowColumnStatsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showPartitions`. + * @param ctx the parse tree + */ + enterShowPartitions?: (ctx: ShowPartitionsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showPartitions`. + * @param ctx the parse tree + */ + exitShowPartitions?: (ctx: ShowPartitionsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showFiles`. + * @param ctx the parse tree + */ + enterShowFiles?: (ctx: ShowFilesContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showFiles`. + * @param ctx the parse tree + */ + exitShowFiles?: (ctx: ShowFilesContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showRoles`. + * @param ctx the parse tree + */ + enterShowRoles?: (ctx: ShowRolesContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showRoles`. + * @param ctx the parse tree + */ + exitShowRoles?: (ctx: ShowRolesContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showRoleGrant`. + * @param ctx the parse tree + */ + enterShowRoleGrant?: (ctx: ShowRoleGrantContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showRoleGrant`. + * @param ctx the parse tree + */ + exitShowRoleGrant?: (ctx: ShowRoleGrantContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showGrants`. + * @param ctx the parse tree + */ + enterShowGrants?: (ctx: ShowGrantsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showGrants`. + * @param ctx the parse tree + */ + exitShowGrants?: (ctx: ShowGrantsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showDatabaseGrant`. + * @param ctx the parse tree + */ + enterShowDatabaseGrant?: (ctx: ShowDatabaseGrantContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showDatabaseGrant`. + * @param ctx the parse tree + */ + exitShowDatabaseGrant?: (ctx: ShowDatabaseGrantContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showTableGrant`. + * @param ctx the parse tree + */ + enterShowTableGrant?: (ctx: ShowTableGrantContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showTableGrant`. + * @param ctx the parse tree + */ + exitShowTableGrant?: (ctx: ShowTableGrantContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.showColumnGrant`. + * @param ctx the parse tree + */ + enterShowColumnGrant?: (ctx: ShowColumnGrantContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.showColumnGrant`. + * @param ctx the parse tree + */ + exitShowColumnGrant?: (ctx: ShowColumnGrantContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.addCommentStatement`. + * @param ctx the parse tree + */ + enterAddCommentStatement?: (ctx: AddCommentStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.addCommentStatement`. + * @param ctx the parse tree + */ + exitAddCommentStatement?: (ctx: AddCommentStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.addDatabaseComments`. + * @param ctx the parse tree + */ + enterAddDatabaseComments?: (ctx: AddDatabaseCommentsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.addDatabaseComments`. + * @param ctx the parse tree + */ + exitAddDatabaseComments?: (ctx: AddDatabaseCommentsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.addTableComments`. + * @param ctx the parse tree + */ + enterAddTableComments?: (ctx: AddTableCommentsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.addTableComments`. + * @param ctx the parse tree + */ + exitAddTableComments?: (ctx: AddTableCommentsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.addColumnComments`. + * @param ctx the parse tree + */ + enterAddColumnComments?: (ctx: AddColumnCommentsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.addColumnComments`. + * @param ctx the parse tree + */ + exitAddColumnComments?: (ctx: AddColumnCommentsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.explainStatement`. + * @param ctx the parse tree + */ + enterExplainStatement?: (ctx: ExplainStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.explainStatement`. + * @param ctx the parse tree + */ + exitExplainStatement?: (ctx: ExplainStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.setStatement`. + * @param ctx the parse tree + */ + enterSetStatement?: (ctx: SetStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.setStatement`. + * @param ctx the parse tree + */ + exitSetStatement?: (ctx: SetStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.shutdownStatement`. + * @param ctx the parse tree + */ + enterShutdownStatement?: (ctx: ShutdownStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.shutdownStatement`. + * @param ctx the parse tree + */ + exitShutdownStatement?: (ctx: ShutdownStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.invalidateMetaStatement`. + * @param ctx the parse tree + */ + enterInvalidateMetaStatement?: (ctx: InvalidateMetaStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.invalidateMetaStatement`. + * @param ctx the parse tree + */ + exitInvalidateMetaStatement?: (ctx: InvalidateMetaStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.loadDataStatement`. + * @param ctx the parse tree + */ + enterLoadDataStatement?: (ctx: LoadDataStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.loadDataStatement`. + * @param ctx the parse tree + */ + exitLoadDataStatement?: (ctx: LoadDataStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.refreshStatement`. + * @param ctx the parse tree + */ + enterRefreshStatement?: (ctx: RefreshStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.refreshStatement`. + * @param ctx the parse tree + */ + exitRefreshStatement?: (ctx: RefreshStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.refreshMeta`. + * @param ctx the parse tree + */ + enterRefreshMeta?: (ctx: RefreshMetaContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.refreshMeta`. + * @param ctx the parse tree + */ + exitRefreshMeta?: (ctx: RefreshMetaContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.refreshAuth`. + * @param ctx the parse tree + */ + enterRefreshAuth?: (ctx: RefreshAuthContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.refreshAuth`. + * @param ctx the parse tree + */ + exitRefreshAuth?: (ctx: RefreshAuthContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.refreshFunction`. + * @param ctx the parse tree + */ + enterRefreshFunction?: (ctx: RefreshFunctionContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.refreshFunction`. + * @param ctx the parse tree + */ + exitRefreshFunction?: (ctx: RefreshFunctionContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.ifExists`. + * @param ctx the parse tree + */ + enterIfExists?: (ctx: IfExistsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.ifExists`. + * @param ctx the parse tree + */ + exitIfExists?: (ctx: IfExistsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.ifNotExists`. + * @param ctx the parse tree + */ + enterIfNotExists?: (ctx: IfNotExistsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.ifNotExists`. + * @param ctx the parse tree + */ + exitIfNotExists?: (ctx: IfNotExistsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.tableNameCreate`. + * @param ctx the parse tree + */ + enterTableNameCreate?: (ctx: TableNameCreateContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.tableNameCreate`. + * @param ctx the parse tree + */ + exitTableNameCreate?: (ctx: TableNameCreateContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.databaseNameCreate`. + * @param ctx the parse tree + */ + enterDatabaseNameCreate?: (ctx: DatabaseNameCreateContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.databaseNameCreate`. + * @param ctx the parse tree + */ + exitDatabaseNameCreate?: (ctx: DatabaseNameCreateContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.viewNameCreate`. + * @param ctx the parse tree + */ + enterViewNameCreate?: (ctx: ViewNameCreateContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.viewNameCreate`. + * @param ctx the parse tree + */ + exitViewNameCreate?: (ctx: ViewNameCreateContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.functionNameCreate`. + * @param ctx the parse tree + */ + enterFunctionNameCreate?: (ctx: FunctionNameCreateContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.functionNameCreate`. + * @param ctx the parse tree + */ + exitFunctionNameCreate?: (ctx: FunctionNameCreateContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.columnNamePathCreate`. + * @param ctx the parse tree + */ + enterColumnNamePathCreate?: (ctx: ColumnNamePathCreateContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.columnNamePathCreate`. + * @param ctx the parse tree + */ + exitColumnNamePathCreate?: (ctx: ColumnNamePathCreateContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.databaseNamePath`. + * @param ctx the parse tree + */ + enterDatabaseNamePath?: (ctx: DatabaseNamePathContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.databaseNamePath`. + * @param ctx the parse tree + */ + exitDatabaseNamePath?: (ctx: DatabaseNamePathContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.tableNamePath`. + * @param ctx the parse tree + */ + enterTableNamePath?: (ctx: TableNamePathContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.tableNamePath`. + * @param ctx the parse tree + */ + exitTableNamePath?: (ctx: TableNamePathContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.viewNamePath`. + * @param ctx the parse tree + */ + enterViewNamePath?: (ctx: ViewNamePathContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.viewNamePath`. + * @param ctx the parse tree + */ + exitViewNamePath?: (ctx: ViewNamePathContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.functionNamePath`. + * @param ctx the parse tree + */ + enterFunctionNamePath?: (ctx: FunctionNamePathContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.functionNamePath`. + * @param ctx the parse tree + */ + exitFunctionNamePath?: (ctx: FunctionNamePathContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.columnNamePath`. + * @param ctx the parse tree + */ + enterColumnNamePath?: (ctx: ColumnNamePathContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.columnNamePath`. + * @param ctx the parse tree + */ + exitColumnNamePath?: (ctx: ColumnNamePathContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.tableOrViewPath`. + * @param ctx the parse tree + */ + enterTableOrViewPath?: (ctx: TableOrViewPathContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.tableOrViewPath`. + * @param ctx the parse tree + */ + exitTableOrViewPath?: (ctx: TableOrViewPathContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.createCommonItem`. + * @param ctx the parse tree + */ + enterCreateCommonItem?: (ctx: CreateCommonItemContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.createCommonItem`. + * @param ctx the parse tree + */ + exitCreateCommonItem?: (ctx: CreateCommonItemContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.assignmentList`. + * @param ctx the parse tree + */ + enterAssignmentList?: (ctx: AssignmentListContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.assignmentList`. + * @param ctx the parse tree + */ + exitAssignmentList?: (ctx: AssignmentListContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.assignmentItem`. + * @param ctx the parse tree + */ + enterAssignmentItem?: (ctx: AssignmentItemContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.assignmentItem`. + * @param ctx the parse tree + */ + exitAssignmentItem?: (ctx: AssignmentItemContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.viewColumns`. + * @param ctx the parse tree + */ + enterViewColumns?: (ctx: ViewColumnsContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.viewColumns`. + * @param ctx the parse tree + */ + exitViewColumns?: (ctx: ViewColumnsContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.queryStatement`. + * @param ctx the parse tree + */ + enterQueryStatement?: (ctx: QueryStatementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.queryStatement`. + * @param ctx the parse tree + */ + exitQueryStatement?: (ctx: QueryStatementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.with`. + * @param ctx the parse tree + */ + enterWith?: (ctx: WithContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.with`. + * @param ctx the parse tree + */ + exitWith?: (ctx: WithContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.constraintSpecification`. + * @param ctx the parse tree + */ + enterConstraintSpecification?: (ctx: ConstraintSpecificationContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.constraintSpecification`. + * @param ctx the parse tree + */ + exitConstraintSpecification?: (ctx: ConstraintSpecificationContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.foreignKeySpecification`. + * @param ctx the parse tree + */ + enterForeignKeySpecification?: (ctx: ForeignKeySpecificationContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.foreignKeySpecification`. + * @param ctx the parse tree + */ + exitForeignKeySpecification?: (ctx: ForeignKeySpecificationContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.columnDefinition`. + * @param ctx the parse tree + */ + enterColumnDefinition?: (ctx: ColumnDefinitionContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.columnDefinition`. + * @param ctx the parse tree + */ + exitColumnDefinition?: (ctx: ColumnDefinitionContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.kuduTableElement`. + * @param ctx the parse tree + */ + enterKuduTableElement?: (ctx: KuduTableElementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.kuduTableElement`. + * @param ctx the parse tree + */ + exitKuduTableElement?: (ctx: KuduTableElementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.kuduColumnDefinition`. + * @param ctx the parse tree + */ + enterKuduColumnDefinition?: (ctx: KuduColumnDefinitionContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.kuduColumnDefinition`. + * @param ctx the parse tree + */ + exitKuduColumnDefinition?: (ctx: KuduColumnDefinitionContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.columnSpecWithKudu`. + * @param ctx the parse tree + */ + enterColumnSpecWithKudu?: (ctx: ColumnSpecWithKuduContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.columnSpecWithKudu`. + * @param ctx the parse tree + */ + exitColumnSpecWithKudu?: (ctx: ColumnSpecWithKuduContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.createColumnSpecWithKudu`. + * @param ctx the parse tree + */ + enterCreateColumnSpecWithKudu?: (ctx: CreateColumnSpecWithKuduContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.createColumnSpecWithKudu`. + * @param ctx the parse tree + */ + exitCreateColumnSpecWithKudu?: (ctx: CreateColumnSpecWithKuduContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.kuduAttributes`. + * @param ctx the parse tree + */ + enterKuduAttributes?: (ctx: KuduAttributesContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.kuduAttributes`. + * @param ctx the parse tree + */ + exitKuduAttributes?: (ctx: KuduAttributesContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.kuduStorageAttr`. + * @param ctx the parse tree + */ + enterKuduStorageAttr?: (ctx: KuduStorageAttrContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.kuduStorageAttr`. + * @param ctx the parse tree + */ + exitKuduStorageAttr?: (ctx: KuduStorageAttrContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.statsKey`. + * @param ctx the parse tree + */ + enterStatsKey?: (ctx: StatsKeyContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.statsKey`. + * @param ctx the parse tree + */ + exitStatsKey?: (ctx: StatsKeyContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.fileFormat`. + * @param ctx the parse tree + */ + enterFileFormat?: (ctx: FileFormatContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.fileFormat`. + * @param ctx the parse tree + */ + exitFileFormat?: (ctx: FileFormatContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.kuduPartitionClause`. + * @param ctx the parse tree + */ + enterKuduPartitionClause?: (ctx: KuduPartitionClauseContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.kuduPartitionClause`. + * @param ctx the parse tree + */ + exitKuduPartitionClause?: (ctx: KuduPartitionClauseContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.hashClause`. + * @param ctx the parse tree + */ + enterHashClause?: (ctx: HashClauseContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.hashClause`. + * @param ctx the parse tree + */ + exitHashClause?: (ctx: HashClauseContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.rangeClause`. + * @param ctx the parse tree + */ + enterRangeClause?: (ctx: RangeClauseContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.rangeClause`. + * @param ctx the parse tree + */ + exitRangeClause?: (ctx: RangeClauseContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.kuduPartitionSpec`. + * @param ctx the parse tree + */ + enterKuduPartitionSpec?: (ctx: KuduPartitionSpecContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.kuduPartitionSpec`. + * @param ctx the parse tree + */ + exitKuduPartitionSpec?: (ctx: KuduPartitionSpecContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.cacheSpec`. + * @param ctx the parse tree + */ + enterCacheSpec?: (ctx: CacheSpecContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.cacheSpec`. + * @param ctx the parse tree + */ + exitCacheSpec?: (ctx: CacheSpecContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.rangeOperator`. + * @param ctx the parse tree + */ + enterRangeOperator?: (ctx: RangeOperatorContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.rangeOperator`. + * @param ctx the parse tree + */ + exitRangeOperator?: (ctx: RangeOperatorContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.partitionCol`. + * @param ctx the parse tree + */ + enterPartitionCol?: (ctx: PartitionColContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.partitionCol`. + * @param ctx the parse tree + */ + exitPartitionCol?: (ctx: PartitionColContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.likeClause`. + * @param ctx the parse tree + */ + enterLikeClause?: (ctx: LikeClauseContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.likeClause`. + * @param ctx the parse tree + */ + exitLikeClause?: (ctx: LikeClauseContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.properties`. + * @param ctx the parse tree + */ + enterProperties?: (ctx: PropertiesContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.properties`. + * @param ctx the parse tree + */ + exitProperties?: (ctx: PropertiesContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.partitionedBy`. + * @param ctx the parse tree + */ + enterPartitionedBy?: (ctx: PartitionedByContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.partitionedBy`. + * @param ctx the parse tree + */ + exitPartitionedBy?: (ctx: PartitionedByContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.sortedBy`. + * @param ctx the parse tree + */ + enterSortedBy?: (ctx: SortedByContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.sortedBy`. + * @param ctx the parse tree + */ + exitSortedBy?: (ctx: SortedByContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.rowFormat`. + * @param ctx the parse tree + */ + enterRowFormat?: (ctx: RowFormatContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.rowFormat`. + * @param ctx the parse tree + */ + exitRowFormat?: (ctx: RowFormatContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.property`. + * @param ctx the parse tree + */ + enterProperty?: (ctx: PropertyContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.property`. + * @param ctx the parse tree + */ + exitProperty?: (ctx: PropertyContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.queryNoWith`. + * @param ctx the parse tree + */ + enterQueryNoWith?: (ctx: QueryNoWithContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.queryNoWith`. + * @param ctx the parse tree + */ + exitQueryNoWith?: (ctx: QueryNoWithContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.queryTerm`. + * @param ctx the parse tree + */ + enterQueryTerm?: (ctx: QueryTermContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.queryTerm`. + * @param ctx the parse tree + */ + exitQueryTerm?: (ctx: QueryTermContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + */ + enterQueryPrimary?: (ctx: QueryPrimaryContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + */ + exitQueryPrimary?: (ctx: QueryPrimaryContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.sortItem`. + * @param ctx the parse tree + */ + enterSortItem?: (ctx: SortItemContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.sortItem`. + * @param ctx the parse tree + */ + exitSortItem?: (ctx: SortItemContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.querySpecification`. + * @param ctx the parse tree + */ + enterQuerySpecification?: (ctx: QuerySpecificationContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.querySpecification`. + * @param ctx the parse tree + */ + exitQuerySpecification?: (ctx: QuerySpecificationContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.groupBy`. + * @param ctx the parse tree + */ + enterGroupBy?: (ctx: GroupByContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.groupBy`. + * @param ctx the parse tree + */ + exitGroupBy?: (ctx: GroupByContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.groupingElement`. + * @param ctx the parse tree + */ + enterGroupingElement?: (ctx: GroupingElementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.groupingElement`. + * @param ctx the parse tree + */ + exitGroupingElement?: (ctx: GroupingElementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.groupingSet`. + * @param ctx the parse tree + */ + enterGroupingSet?: (ctx: GroupingSetContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.groupingSet`. + * @param ctx the parse tree + */ + exitGroupingSet?: (ctx: GroupingSetContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.namedQuery`. + * @param ctx the parse tree + */ + enterNamedQuery?: (ctx: NamedQueryContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.namedQuery`. + * @param ctx the parse tree + */ + exitNamedQuery?: (ctx: NamedQueryContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.setQuantifier`. + * @param ctx the parse tree + */ + enterSetQuantifier?: (ctx: SetQuantifierContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.setQuantifier`. + * @param ctx the parse tree + */ + exitSetQuantifier?: (ctx: SetQuantifierContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.selectItem`. + * @param ctx the parse tree + */ + enterSelectItem?: (ctx: SelectItemContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.selectItem`. + * @param ctx the parse tree + */ + exitSelectItem?: (ctx: SelectItemContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.relation`. + * @param ctx the parse tree + */ + enterRelation?: (ctx: RelationContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.relation`. + * @param ctx the parse tree + */ + exitRelation?: (ctx: RelationContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.joinType`. + * @param ctx the parse tree + */ + enterJoinType?: (ctx: JoinTypeContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.joinType`. + * @param ctx the parse tree + */ + exitJoinType?: (ctx: JoinTypeContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.joinCriteria`. + * @param ctx the parse tree + */ + enterJoinCriteria?: (ctx: JoinCriteriaContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.joinCriteria`. + * @param ctx the parse tree + */ + exitJoinCriteria?: (ctx: JoinCriteriaContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.sampledRelation`. + * @param ctx the parse tree + */ + enterSampledRelation?: (ctx: SampledRelationContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.sampledRelation`. + * @param ctx the parse tree + */ + exitSampledRelation?: (ctx: SampledRelationContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.sampleType`. + * @param ctx the parse tree + */ + enterSampleType?: (ctx: SampleTypeContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.sampleType`. + * @param ctx the parse tree + */ + exitSampleType?: (ctx: SampleTypeContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.aliasedRelation`. + * @param ctx the parse tree + */ + enterAliasedRelation?: (ctx: AliasedRelationContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.aliasedRelation`. + * @param ctx the parse tree + */ + exitAliasedRelation?: (ctx: AliasedRelationContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.columnAliases`. + * @param ctx the parse tree + */ + enterColumnAliases?: (ctx: ColumnAliasesContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.columnAliases`. + * @param ctx the parse tree + */ + exitColumnAliases?: (ctx: ColumnAliasesContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.createColumnAliases`. + * @param ctx the parse tree + */ + enterCreateColumnAliases?: (ctx: CreateColumnAliasesContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.createColumnAliases`. + * @param ctx the parse tree + */ + exitCreateColumnAliases?: (ctx: CreateColumnAliasesContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.relationPrimary`. + * @param ctx the parse tree + */ + enterRelationPrimary?: (ctx: RelationPrimaryContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.relationPrimary`. + * @param ctx the parse tree + */ + exitRelationPrimary?: (ctx: RelationPrimaryContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.subQueryRelation`. + * @param ctx the parse tree + */ + enterSubQueryRelation?: (ctx: SubQueryRelationContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.subQueryRelation`. + * @param ctx the parse tree + */ + exitSubQueryRelation?: (ctx: SubQueryRelationContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.unnest`. + * @param ctx the parse tree + */ + enterUnnest?: (ctx: UnnestContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.unnest`. + * @param ctx the parse tree + */ + exitUnnest?: (ctx: UnnestContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.parenthesizedRelation`. + * @param ctx the parse tree + */ + enterParenthesizedRelation?: (ctx: ParenthesizedRelationContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.parenthesizedRelation`. + * @param ctx the parse tree + */ + exitParenthesizedRelation?: (ctx: ParenthesizedRelationContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.columnItem`. + * @param ctx the parse tree + */ + enterColumnItem?: (ctx: ColumnItemContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.columnItem`. + * @param ctx the parse tree + */ + exitColumnItem?: (ctx: ColumnItemContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.expression`. + * @param ctx the parse tree + */ + enterExpression?: (ctx: ExpressionContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.expression`. + * @param ctx the parse tree + */ + exitExpression?: (ctx: ExpressionContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.booleanExpression`. + * @param ctx the parse tree + */ + enterBooleanExpression?: (ctx: BooleanExpressionContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.booleanExpression`. + * @param ctx the parse tree + */ + exitBooleanExpression?: (ctx: BooleanExpressionContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + enterPredicate?: (ctx: PredicateContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + */ + exitPredicate?: (ctx: PredicateContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + */ + enterValueExpression?: (ctx: ValueExpressionContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + */ + exitValueExpression?: (ctx: ValueExpressionContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + enterPrimaryExpression?: (ctx: PrimaryExpressionContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + */ + exitPrimaryExpression?: (ctx: PrimaryExpressionContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.stringLiteral`. + * @param ctx the parse tree + */ + enterStringLiteral?: (ctx: StringLiteralContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.stringLiteral`. + * @param ctx the parse tree + */ + exitStringLiteral?: (ctx: StringLiteralContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.comparisonOperator`. + * @param ctx the parse tree + */ + enterComparisonOperator?: (ctx: ComparisonOperatorContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.comparisonOperator`. + * @param ctx the parse tree + */ + exitComparisonOperator?: (ctx: ComparisonOperatorContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.comparisonQuantifier`. + * @param ctx the parse tree + */ + enterComparisonQuantifier?: (ctx: ComparisonQuantifierContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.comparisonQuantifier`. + * @param ctx the parse tree + */ + exitComparisonQuantifier?: (ctx: ComparisonQuantifierContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.booleanValue`. + * @param ctx the parse tree + */ + enterBooleanValue?: (ctx: BooleanValueContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.booleanValue`. + * @param ctx the parse tree + */ + exitBooleanValue?: (ctx: BooleanValueContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.interval`. + * @param ctx the parse tree + */ + enterInterval?: (ctx: IntervalContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.interval`. + * @param ctx the parse tree + */ + exitInterval?: (ctx: IntervalContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.intervalField`. + * @param ctx the parse tree + */ + enterIntervalField?: (ctx: IntervalFieldContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.intervalField`. + * @param ctx the parse tree + */ + exitIntervalField?: (ctx: IntervalFieldContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.normalForm`. + * @param ctx the parse tree + */ + enterNormalForm?: (ctx: NormalFormContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.normalForm`. + * @param ctx the parse tree + */ + exitNormalForm?: (ctx: NormalFormContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.type`. + * @param ctx the parse tree + */ + enterType?: (ctx: TypeContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.type`. + * @param ctx the parse tree + */ + exitType?: (ctx: TypeContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.typeParameter`. + * @param ctx the parse tree + */ + enterTypeParameter?: (ctx: TypeParameterContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.typeParameter`. + * @param ctx the parse tree + */ + exitTypeParameter?: (ctx: TypeParameterContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.baseType`. + * @param ctx the parse tree + */ + enterBaseType?: (ctx: BaseTypeContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.baseType`. + * @param ctx the parse tree + */ + exitBaseType?: (ctx: BaseTypeContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.whenClause`. + * @param ctx the parse tree + */ + enterWhenClause?: (ctx: WhenClauseContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.whenClause`. + * @param ctx the parse tree + */ + exitWhenClause?: (ctx: WhenClauseContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.filter`. + * @param ctx the parse tree + */ + enterFilter?: (ctx: FilterContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.filter`. + * @param ctx the parse tree + */ + exitFilter?: (ctx: FilterContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.over`. + * @param ctx the parse tree + */ + enterOver?: (ctx: OverContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.over`. + * @param ctx the parse tree + */ + exitOver?: (ctx: OverContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.windowFrame`. + * @param ctx the parse tree + */ + enterWindowFrame?: (ctx: WindowFrameContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.windowFrame`. + * @param ctx the parse tree + */ + exitWindowFrame?: (ctx: WindowFrameContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.frameBound`. + * @param ctx the parse tree + */ + enterFrameBound?: (ctx: FrameBoundContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.frameBound`. + * @param ctx the parse tree + */ + exitFrameBound?: (ctx: FrameBoundContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.pathElement`. + * @param ctx the parse tree + */ + enterPathElement?: (ctx: PathElementContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.pathElement`. + * @param ctx the parse tree + */ + exitPathElement?: (ctx: PathElementContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.pathSpecification`. + * @param ctx the parse tree + */ + enterPathSpecification?: (ctx: PathSpecificationContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.pathSpecification`. + * @param ctx the parse tree + */ + exitPathSpecification?: (ctx: PathSpecificationContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.privilege`. + * @param ctx the parse tree + */ + enterPrivilege?: (ctx: PrivilegeContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.privilege`. + * @param ctx the parse tree + */ + exitPrivilege?: (ctx: PrivilegeContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.objectType`. + * @param ctx the parse tree + */ + enterObjectType?: (ctx: ObjectTypeContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.objectType`. + * @param ctx the parse tree + */ + exitObjectType?: (ctx: ObjectTypeContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.qualifiedName`. + * @param ctx the parse tree + */ + enterQualifiedName?: (ctx: QualifiedNameContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.qualifiedName`. + * @param ctx the parse tree + */ + exitQualifiedName?: (ctx: QualifiedNameContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.principal`. + * @param ctx the parse tree + */ + enterPrincipal?: (ctx: PrincipalContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.principal`. + * @param ctx the parse tree + */ + exitPrincipal?: (ctx: PrincipalContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + */ + enterIdentifier?: (ctx: IdentifierContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + */ + exitIdentifier?: (ctx: IdentifierContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.number`. + * @param ctx the parse tree + */ + enterNumber?: (ctx: NumberContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.number`. + * @param ctx the parse tree + */ + exitNumber?: (ctx: NumberContext) => void; + + /** + * Enter a parse tree produced by `ImpalaSqlParser.nonReserved`. + * @param ctx the parse tree + */ + enterNonReserved?: (ctx: NonReservedContext) => void; + /** + * Exit a parse tree produced by `ImpalaSqlParser.nonReserved`. + * @param ctx the parse tree + */ + exitNonReserved?: (ctx: NonReservedContext) => void; +} + diff --git a/src/lib/impala/ImpalaSqlParserVisitor.ts b/src/lib/impala/ImpalaSqlParserVisitor.ts new file mode 100644 index 0000000..afc4b5a --- /dev/null +++ b/src/lib/impala/ImpalaSqlParserVisitor.ts @@ -0,0 +1,2113 @@ +// Generated from /Users/shuangxu/Documents/workspace/dt-sql-parser/src/grammar/impala/ImpalaSqlParser.g4 by ANTLR 4.9.0-SNAPSHOT + + +import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor"; + +import { JoinRelationContext } from "./ImpalaSqlParser"; +import { RelationDefaultContext } from "./ImpalaSqlParser"; +import { ComparisonContext } from "./ImpalaSqlParser"; +import { QuantifiedComparisonContext } from "./ImpalaSqlParser"; +import { BetweenContext } from "./ImpalaSqlParser"; +import { InListContext } from "./ImpalaSqlParser"; +import { InSubqueryContext } from "./ImpalaSqlParser"; +import { LikeContext } from "./ImpalaSqlParser"; +import { REGEXPContext } from "./ImpalaSqlParser"; +import { NullPredicateContext } from "./ImpalaSqlParser"; +import { DistinctFromContext } from "./ImpalaSqlParser"; +import { DecimalLiteralContext } from "./ImpalaSqlParser"; +import { DoubleLiteralContext } from "./ImpalaSqlParser"; +import { IntegerLiteralContext } from "./ImpalaSqlParser"; +import { QueryTermDefaultContext } from "./ImpalaSqlParser"; +import { SetOperationContext } from "./ImpalaSqlParser"; +import { UnquotedIdentifierContext } from "./ImpalaSqlParser"; +import { QuotedIdentifierContext } from "./ImpalaSqlParser"; +import { BackQuotedIdentifierContext } from "./ImpalaSqlParser"; +import { DigitIdentifierContext } from "./ImpalaSqlParser"; +import { SingleGroupingSetContext } from "./ImpalaSqlParser"; +import { BasicStringLiteralContext } from "./ImpalaSqlParser"; +import { UnicodeStringLiteralContext } from "./ImpalaSqlParser"; +import { ValueExpressionDefaultContext } from "./ImpalaSqlParser"; +import { ArithmeticUnaryContext } from "./ImpalaSqlParser"; +import { ArithmeticBinaryContext } from "./ImpalaSqlParser"; +import { ConcatenationContext } from "./ImpalaSqlParser"; +import { UnboundedFrameContext } from "./ImpalaSqlParser"; +import { CurrentRowBoundContext } from "./ImpalaSqlParser"; +import { BoundedFrameContext } from "./ImpalaSqlParser"; +import { QueryPrimaryDefaultContext } from "./ImpalaSqlParser"; +import { TableContext } from "./ImpalaSqlParser"; +import { InlineTableContext } from "./ImpalaSqlParser"; +import { SubqueryContext } from "./ImpalaSqlParser"; +import { NullLiteralContext } from "./ImpalaSqlParser"; +import { IntervalLiteralContext } from "./ImpalaSqlParser"; +import { TypeConstructorContext } from "./ImpalaSqlParser"; +import { NumericLiteralContext } from "./ImpalaSqlParser"; +import { BooleanLiteralContext } from "./ImpalaSqlParser"; +import { StringLiteralValuesContext } from "./ImpalaSqlParser"; +import { BinaryLiteralContext } from "./ImpalaSqlParser"; +import { ParameterContext } from "./ImpalaSqlParser"; +import { PositionContext } from "./ImpalaSqlParser"; +import { RowConstructorContext } from "./ImpalaSqlParser"; +import { FunctionCallContext } from "./ImpalaSqlParser"; +import { LambdaContext } from "./ImpalaSqlParser"; +import { SubqueryExpressionContext } from "./ImpalaSqlParser"; +import { ExistsContext } from "./ImpalaSqlParser"; +import { SimpleCaseContext } from "./ImpalaSqlParser"; +import { SearchedCaseContext } from "./ImpalaSqlParser"; +import { CastContext } from "./ImpalaSqlParser"; +import { ArrayConstructorContext } from "./ImpalaSqlParser"; +import { SubscriptContext } from "./ImpalaSqlParser"; +import { ColumnReferenceContext } from "./ImpalaSqlParser"; +import { DereferenceContext } from "./ImpalaSqlParser"; +import { SpecialDateTimeFunctionContext } from "./ImpalaSqlParser"; +import { CurrentUserContext } from "./ImpalaSqlParser"; +import { CurrentPathContext } from "./ImpalaSqlParser"; +import { SubstringContext } from "./ImpalaSqlParser"; +import { NormalizeContext } from "./ImpalaSqlParser"; +import { ExtractContext } from "./ImpalaSqlParser"; +import { ParenthesizedExpressionContext } from "./ImpalaSqlParser"; +import { GroupingOperationContext } from "./ImpalaSqlParser"; +import { SelectSingleContext } from "./ImpalaSqlParser"; +import { SelectAllContext } from "./ImpalaSqlParser"; +import { QualifiedArgumentContext } from "./ImpalaSqlParser"; +import { UnqualifiedArgumentContext } from "./ImpalaSqlParser"; +import { RolePrincipalContext } from "./ImpalaSqlParser"; +import { UserPrincipalContext } from "./ImpalaSqlParser"; +import { GroupPrincipalContext } from "./ImpalaSqlParser"; +import { PredicatedContext } from "./ImpalaSqlParser"; +import { LogicalNotContext } from "./ImpalaSqlParser"; +import { LogicalBinaryContext } from "./ImpalaSqlParser"; +import { ProgramContext } from "./ImpalaSqlParser"; +import { StatementContext } from "./ImpalaSqlParser"; +import { UseStatementContext } from "./ImpalaSqlParser"; +import { CreateStatementContext } from "./ImpalaSqlParser"; +import { CreateTableSelectContext } from "./ImpalaSqlParser"; +import { CreateTableLikeContext } from "./ImpalaSqlParser"; +import { CreateKuduTableAsSelectContext } from "./ImpalaSqlParser"; +import { CreateViewContext } from "./ImpalaSqlParser"; +import { CreateSchemaContext } from "./ImpalaSqlParser"; +import { CreateRoleContext } from "./ImpalaSqlParser"; +import { CreateAggregateFunctionContext } from "./ImpalaSqlParser"; +import { CreateFunctionContext } from "./ImpalaSqlParser"; +import { AlterStatementContext } from "./ImpalaSqlParser"; +import { AlterDatabaseContext } from "./ImpalaSqlParser"; +import { AlterStatsKeyContext } from "./ImpalaSqlParser"; +import { AlterPartitionCacheContext } from "./ImpalaSqlParser"; +import { ChangeColumnDefineContext } from "./ImpalaSqlParser"; +import { AlterDropSingleColumnContext } from "./ImpalaSqlParser"; +import { AlterTableOwnerContext } from "./ImpalaSqlParser"; +import { ReplaceOrAddColumnsContext } from "./ImpalaSqlParser"; +import { AddSingleColumnContext } from "./ImpalaSqlParser"; +import { AlterTableNonKuduOrKuduOnlyContext } from "./ImpalaSqlParser"; +import { AddPartitionByRangeOrValueContext } from "./ImpalaSqlParser"; +import { AlterFormatContext } from "./ImpalaSqlParser"; +import { RecoverPartitionsContext } from "./ImpalaSqlParser"; +import { DropPartitionByRangeOrValueContext } from "./ImpalaSqlParser"; +import { AlterViewContext } from "./ImpalaSqlParser"; +import { RenameViewContext } from "./ImpalaSqlParser"; +import { AlterViewOwnerContext } from "./ImpalaSqlParser"; +import { RenameTableContext } from "./ImpalaSqlParser"; +import { AlterUnSetOrSetViewTblpropertiesContext } from "./ImpalaSqlParser"; +import { TruncateTableStatementContext } from "./ImpalaSqlParser"; +import { DescribeStatementContext } from "./ImpalaSqlParser"; +import { ComputeStatementContext } from "./ImpalaSqlParser"; +import { ComputeStatsContext } from "./ImpalaSqlParser"; +import { ComputeIncrementalStatsContext } from "./ImpalaSqlParser"; +import { DropStatementContext } from "./ImpalaSqlParser"; +import { DropSchemaContext } from "./ImpalaSqlParser"; +import { DropViewContext } from "./ImpalaSqlParser"; +import { DropTableContext } from "./ImpalaSqlParser"; +import { DropIncrementalStatsContext } from "./ImpalaSqlParser"; +import { DropFunctionContext } from "./ImpalaSqlParser"; +import { DropRoleContext } from "./ImpalaSqlParser"; +import { GrantStatementContext } from "./ImpalaSqlParser"; +import { GrantRoleContext } from "./ImpalaSqlParser"; +import { GrantContext } from "./ImpalaSqlParser"; +import { RevokeStatementContext } from "./ImpalaSqlParser"; +import { RevokeRoleContext } from "./ImpalaSqlParser"; +import { RevokeContext } from "./ImpalaSqlParser"; +import { InsertStatementContext } from "./ImpalaSqlParser"; +import { DeleteStatementContext } from "./ImpalaSqlParser"; +import { DeleteContext } from "./ImpalaSqlParser"; +import { DeleteTableRefContext } from "./ImpalaSqlParser"; +import { UpdateStatementContext } from "./ImpalaSqlParser"; +import { UpsertStatementContext } from "./ImpalaSqlParser"; +import { ShowStatementContext } from "./ImpalaSqlParser"; +import { ShowSchemasContext } from "./ImpalaSqlParser"; +import { ShowTablesContext } from "./ImpalaSqlParser"; +import { ShowFunctionsContext } from "./ImpalaSqlParser"; +import { ShowCreateTableContext } from "./ImpalaSqlParser"; +import { ShowCreateViewContext } from "./ImpalaSqlParser"; +import { ShowTableStatsContext } from "./ImpalaSqlParser"; +import { ShowColumnStatsContext } from "./ImpalaSqlParser"; +import { ShowPartitionsContext } from "./ImpalaSqlParser"; +import { ShowFilesContext } from "./ImpalaSqlParser"; +import { ShowRolesContext } from "./ImpalaSqlParser"; +import { ShowRoleGrantContext } from "./ImpalaSqlParser"; +import { ShowGrantsContext } from "./ImpalaSqlParser"; +import { ShowDatabaseGrantContext } from "./ImpalaSqlParser"; +import { ShowTableGrantContext } from "./ImpalaSqlParser"; +import { ShowColumnGrantContext } from "./ImpalaSqlParser"; +import { AddCommentStatementContext } from "./ImpalaSqlParser"; +import { AddDatabaseCommentsContext } from "./ImpalaSqlParser"; +import { AddTableCommentsContext } from "./ImpalaSqlParser"; +import { AddColumnCommentsContext } from "./ImpalaSqlParser"; +import { ExplainStatementContext } from "./ImpalaSqlParser"; +import { SetStatementContext } from "./ImpalaSqlParser"; +import { ShutdownStatementContext } from "./ImpalaSqlParser"; +import { InvalidateMetaStatementContext } from "./ImpalaSqlParser"; +import { LoadDataStatementContext } from "./ImpalaSqlParser"; +import { RefreshStatementContext } from "./ImpalaSqlParser"; +import { RefreshMetaContext } from "./ImpalaSqlParser"; +import { RefreshAuthContext } from "./ImpalaSqlParser"; +import { RefreshFunctionContext } from "./ImpalaSqlParser"; +import { IfExistsContext } from "./ImpalaSqlParser"; +import { IfNotExistsContext } from "./ImpalaSqlParser"; +import { TableNameCreateContext } from "./ImpalaSqlParser"; +import { DatabaseNameCreateContext } from "./ImpalaSqlParser"; +import { ViewNameCreateContext } from "./ImpalaSqlParser"; +import { FunctionNameCreateContext } from "./ImpalaSqlParser"; +import { ColumnNamePathCreateContext } from "./ImpalaSqlParser"; +import { DatabaseNamePathContext } from "./ImpalaSqlParser"; +import { TableNamePathContext } from "./ImpalaSqlParser"; +import { ViewNamePathContext } from "./ImpalaSqlParser"; +import { FunctionNamePathContext } from "./ImpalaSqlParser"; +import { ColumnNamePathContext } from "./ImpalaSqlParser"; +import { TableOrViewPathContext } from "./ImpalaSqlParser"; +import { CreateCommonItemContext } from "./ImpalaSqlParser"; +import { AssignmentListContext } from "./ImpalaSqlParser"; +import { AssignmentItemContext } from "./ImpalaSqlParser"; +import { ViewColumnsContext } from "./ImpalaSqlParser"; +import { QueryStatementContext } from "./ImpalaSqlParser"; +import { WithContext } from "./ImpalaSqlParser"; +import { ConstraintSpecificationContext } from "./ImpalaSqlParser"; +import { ForeignKeySpecificationContext } from "./ImpalaSqlParser"; +import { ColumnDefinitionContext } from "./ImpalaSqlParser"; +import { KuduTableElementContext } from "./ImpalaSqlParser"; +import { KuduColumnDefinitionContext } from "./ImpalaSqlParser"; +import { ColumnSpecWithKuduContext } from "./ImpalaSqlParser"; +import { CreateColumnSpecWithKuduContext } from "./ImpalaSqlParser"; +import { KuduAttributesContext } from "./ImpalaSqlParser"; +import { KuduStorageAttrContext } from "./ImpalaSqlParser"; +import { StatsKeyContext } from "./ImpalaSqlParser"; +import { FileFormatContext } from "./ImpalaSqlParser"; +import { KuduPartitionClauseContext } from "./ImpalaSqlParser"; +import { HashClauseContext } from "./ImpalaSqlParser"; +import { RangeClauseContext } from "./ImpalaSqlParser"; +import { KuduPartitionSpecContext } from "./ImpalaSqlParser"; +import { CacheSpecContext } from "./ImpalaSqlParser"; +import { RangeOperatorContext } from "./ImpalaSqlParser"; +import { PartitionColContext } from "./ImpalaSqlParser"; +import { LikeClauseContext } from "./ImpalaSqlParser"; +import { PropertiesContext } from "./ImpalaSqlParser"; +import { PartitionedByContext } from "./ImpalaSqlParser"; +import { SortedByContext } from "./ImpalaSqlParser"; +import { RowFormatContext } from "./ImpalaSqlParser"; +import { PropertyContext } from "./ImpalaSqlParser"; +import { QueryNoWithContext } from "./ImpalaSqlParser"; +import { QueryTermContext } from "./ImpalaSqlParser"; +import { QueryPrimaryContext } from "./ImpalaSqlParser"; +import { SortItemContext } from "./ImpalaSqlParser"; +import { QuerySpecificationContext } from "./ImpalaSqlParser"; +import { GroupByContext } from "./ImpalaSqlParser"; +import { GroupingElementContext } from "./ImpalaSqlParser"; +import { GroupingSetContext } from "./ImpalaSqlParser"; +import { NamedQueryContext } from "./ImpalaSqlParser"; +import { SetQuantifierContext } from "./ImpalaSqlParser"; +import { SelectItemContext } from "./ImpalaSqlParser"; +import { RelationContext } from "./ImpalaSqlParser"; +import { JoinTypeContext } from "./ImpalaSqlParser"; +import { JoinCriteriaContext } from "./ImpalaSqlParser"; +import { SampledRelationContext } from "./ImpalaSqlParser"; +import { SampleTypeContext } from "./ImpalaSqlParser"; +import { AliasedRelationContext } from "./ImpalaSqlParser"; +import { ColumnAliasesContext } from "./ImpalaSqlParser"; +import { CreateColumnAliasesContext } from "./ImpalaSqlParser"; +import { RelationPrimaryContext } from "./ImpalaSqlParser"; +import { SubQueryRelationContext } from "./ImpalaSqlParser"; +import { UnnestContext } from "./ImpalaSqlParser"; +import { ParenthesizedRelationContext } from "./ImpalaSqlParser"; +import { ColumnItemContext } from "./ImpalaSqlParser"; +import { ExpressionContext } from "./ImpalaSqlParser"; +import { BooleanExpressionContext } from "./ImpalaSqlParser"; +import { PredicateContext } from "./ImpalaSqlParser"; +import { ValueExpressionContext } from "./ImpalaSqlParser"; +import { PrimaryExpressionContext } from "./ImpalaSqlParser"; +import { StringLiteralContext } from "./ImpalaSqlParser"; +import { ComparisonOperatorContext } from "./ImpalaSqlParser"; +import { ComparisonQuantifierContext } from "./ImpalaSqlParser"; +import { BooleanValueContext } from "./ImpalaSqlParser"; +import { IntervalContext } from "./ImpalaSqlParser"; +import { IntervalFieldContext } from "./ImpalaSqlParser"; +import { NormalFormContext } from "./ImpalaSqlParser"; +import { TypeContext } from "./ImpalaSqlParser"; +import { TypeParameterContext } from "./ImpalaSqlParser"; +import { BaseTypeContext } from "./ImpalaSqlParser"; +import { WhenClauseContext } from "./ImpalaSqlParser"; +import { FilterContext } from "./ImpalaSqlParser"; +import { OverContext } from "./ImpalaSqlParser"; +import { WindowFrameContext } from "./ImpalaSqlParser"; +import { FrameBoundContext } from "./ImpalaSqlParser"; +import { PathElementContext } from "./ImpalaSqlParser"; +import { PathSpecificationContext } from "./ImpalaSqlParser"; +import { PrivilegeContext } from "./ImpalaSqlParser"; +import { ObjectTypeContext } from "./ImpalaSqlParser"; +import { QualifiedNameContext } from "./ImpalaSqlParser"; +import { PrincipalContext } from "./ImpalaSqlParser"; +import { IdentifierContext } from "./ImpalaSqlParser"; +import { NumberContext } from "./ImpalaSqlParser"; +import { NonReservedContext } from "./ImpalaSqlParser"; + + +/** + * This interface defines a complete generic visitor for a parse tree produced + * by `ImpalaSqlParser`. + * + * @param The return type of the visit operation. Use `void` for + * operations with no return type. + */ +export interface ImpalaSqlParserVisitor extends ParseTreeVisitor { + /** + * Visit a parse tree produced by the `joinRelation` + * labeled alternative in `ImpalaSqlParser.relation`. + * @param ctx the parse tree + * @return the visitor result + */ + visitJoinRelation?: (ctx: JoinRelationContext) => Result; + + /** + * Visit a parse tree produced by the `relationDefault` + * labeled alternative in `ImpalaSqlParser.relation`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRelationDefault?: (ctx: RelationDefaultContext) => Result; + + /** + * Visit a parse tree produced by the `comparison` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitComparison?: (ctx: ComparisonContext) => Result; + + /** + * Visit a parse tree produced by the `quantifiedComparison` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQuantifiedComparison?: (ctx: QuantifiedComparisonContext) => Result; + + /** + * Visit a parse tree produced by the `between` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBetween?: (ctx: BetweenContext) => Result; + + /** + * Visit a parse tree produced by the `inList` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInList?: (ctx: InListContext) => Result; + + /** + * Visit a parse tree produced by the `inSubquery` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInSubquery?: (ctx: InSubqueryContext) => Result; + + /** + * Visit a parse tree produced by the `like` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLike?: (ctx: LikeContext) => Result; + + /** + * Visit a parse tree produced by the `REGEXP` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitREGEXP?: (ctx: REGEXPContext) => Result; + + /** + * Visit a parse tree produced by the `nullPredicate` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNullPredicate?: (ctx: NullPredicateContext) => Result; + + /** + * Visit a parse tree produced by the `distinctFrom` + * labeled alternative in `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDistinctFrom?: (ctx: DistinctFromContext) => Result; + + /** + * Visit a parse tree produced by the `decimalLiteral` + * labeled alternative in `ImpalaSqlParser.number`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDecimalLiteral?: (ctx: DecimalLiteralContext) => Result; + + /** + * Visit a parse tree produced by the `doubleLiteral` + * labeled alternative in `ImpalaSqlParser.number`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDoubleLiteral?: (ctx: DoubleLiteralContext) => Result; + + /** + * Visit a parse tree produced by the `integerLiteral` + * labeled alternative in `ImpalaSqlParser.number`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIntegerLiteral?: (ctx: IntegerLiteralContext) => Result; + + /** + * Visit a parse tree produced by the `queryTermDefault` + * labeled alternative in `ImpalaSqlParser.queryTerm`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQueryTermDefault?: (ctx: QueryTermDefaultContext) => Result; + + /** + * Visit a parse tree produced by the `setOperation` + * labeled alternative in `ImpalaSqlParser.queryTerm`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSetOperation?: (ctx: SetOperationContext) => Result; + + /** + * Visit a parse tree produced by the `unquotedIdentifier` + * labeled alternative in `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnquotedIdentifier?: (ctx: UnquotedIdentifierContext) => Result; + + /** + * Visit a parse tree produced by the `quotedIdentifier` + * labeled alternative in `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQuotedIdentifier?: (ctx: QuotedIdentifierContext) => Result; + + /** + * Visit a parse tree produced by the `backQuotedIdentifier` + * labeled alternative in `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBackQuotedIdentifier?: (ctx: BackQuotedIdentifierContext) => Result; + + /** + * Visit a parse tree produced by the `digitIdentifier` + * labeled alternative in `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDigitIdentifier?: (ctx: DigitIdentifierContext) => Result; + + /** + * Visit a parse tree produced by the `singleGroupingSet` + * labeled alternative in `ImpalaSqlParser.groupingElement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSingleGroupingSet?: (ctx: SingleGroupingSetContext) => Result; + + /** + * Visit a parse tree produced by the `basicStringLiteral` + * labeled alternative in `ImpalaSqlParser.stringLiteral`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBasicStringLiteral?: (ctx: BasicStringLiteralContext) => Result; + + /** + * Visit a parse tree produced by the `unicodeStringLiteral` + * labeled alternative in `ImpalaSqlParser.stringLiteral`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnicodeStringLiteral?: (ctx: UnicodeStringLiteralContext) => Result; + + /** + * Visit a parse tree produced by the `valueExpressionDefault` + * labeled alternative in `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitValueExpressionDefault?: (ctx: ValueExpressionDefaultContext) => Result; + + /** + * Visit a parse tree produced by the `arithmeticUnary` + * labeled alternative in `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitArithmeticUnary?: (ctx: ArithmeticUnaryContext) => Result; + + /** + * Visit a parse tree produced by the `arithmeticBinary` + * labeled alternative in `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitArithmeticBinary?: (ctx: ArithmeticBinaryContext) => Result; + + /** + * Visit a parse tree produced by the `concatenation` + * labeled alternative in `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitConcatenation?: (ctx: ConcatenationContext) => Result; + + /** + * Visit a parse tree produced by the `unboundedFrame` + * labeled alternative in `ImpalaSqlParser.frameBound`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnboundedFrame?: (ctx: UnboundedFrameContext) => Result; + + /** + * Visit a parse tree produced by the `currentRowBound` + * labeled alternative in `ImpalaSqlParser.frameBound`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCurrentRowBound?: (ctx: CurrentRowBoundContext) => Result; + + /** + * Visit a parse tree produced by the `boundedFrame` + * labeled alternative in `ImpalaSqlParser.frameBound`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBoundedFrame?: (ctx: BoundedFrameContext) => Result; + + /** + * Visit a parse tree produced by the `queryPrimaryDefault` + * labeled alternative in `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQueryPrimaryDefault?: (ctx: QueryPrimaryDefaultContext) => Result; + + /** + * Visit a parse tree produced by the `table` + * labeled alternative in `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTable?: (ctx: TableContext) => Result; + + /** + * Visit a parse tree produced by the `inlineTable` + * labeled alternative in `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInlineTable?: (ctx: InlineTableContext) => Result; + + /** + * Visit a parse tree produced by the `subquery` + * labeled alternative in `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSubquery?: (ctx: SubqueryContext) => Result; + + /** + * Visit a parse tree produced by the `nullLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNullLiteral?: (ctx: NullLiteralContext) => Result; + + /** + * Visit a parse tree produced by the `intervalLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIntervalLiteral?: (ctx: IntervalLiteralContext) => Result; + + /** + * Visit a parse tree produced by the `typeConstructor` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTypeConstructor?: (ctx: TypeConstructorContext) => Result; + + /** + * Visit a parse tree produced by the `numericLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNumericLiteral?: (ctx: NumericLiteralContext) => Result; + + /** + * Visit a parse tree produced by the `booleanLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBooleanLiteral?: (ctx: BooleanLiteralContext) => Result; + + /** + * Visit a parse tree produced by the `stringLiteralValues` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitStringLiteralValues?: (ctx: StringLiteralValuesContext) => Result; + + /** + * Visit a parse tree produced by the `binaryLiteral` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBinaryLiteral?: (ctx: BinaryLiteralContext) => Result; + + /** + * Visit a parse tree produced by the `parameter` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitParameter?: (ctx: ParameterContext) => Result; + + /** + * Visit a parse tree produced by the `position` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPosition?: (ctx: PositionContext) => Result; + + /** + * Visit a parse tree produced by the `rowConstructor` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRowConstructor?: (ctx: RowConstructorContext) => Result; + + /** + * Visit a parse tree produced by the `functionCall` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFunctionCall?: (ctx: FunctionCallContext) => Result; + + /** + * Visit a parse tree produced by the `lambda` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLambda?: (ctx: LambdaContext) => Result; + + /** + * Visit a parse tree produced by the `subqueryExpression` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSubqueryExpression?: (ctx: SubqueryExpressionContext) => Result; + + /** + * Visit a parse tree produced by the `exists` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitExists?: (ctx: ExistsContext) => Result; + + /** + * Visit a parse tree produced by the `simpleCase` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSimpleCase?: (ctx: SimpleCaseContext) => Result; + + /** + * Visit a parse tree produced by the `searchedCase` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSearchedCase?: (ctx: SearchedCaseContext) => Result; + + /** + * Visit a parse tree produced by the `cast` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCast?: (ctx: CastContext) => Result; + + /** + * Visit a parse tree produced by the `arrayConstructor` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitArrayConstructor?: (ctx: ArrayConstructorContext) => Result; + + /** + * Visit a parse tree produced by the `subscript` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSubscript?: (ctx: SubscriptContext) => Result; + + /** + * Visit a parse tree produced by the `columnReference` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColumnReference?: (ctx: ColumnReferenceContext) => Result; + + /** + * Visit a parse tree produced by the `dereference` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDereference?: (ctx: DereferenceContext) => Result; + + /** + * Visit a parse tree produced by the `specialDateTimeFunction` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSpecialDateTimeFunction?: (ctx: SpecialDateTimeFunctionContext) => Result; + + /** + * Visit a parse tree produced by the `currentUser` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCurrentUser?: (ctx: CurrentUserContext) => Result; + + /** + * Visit a parse tree produced by the `currentPath` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCurrentPath?: (ctx: CurrentPathContext) => Result; + + /** + * Visit a parse tree produced by the `substring` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSubstring?: (ctx: SubstringContext) => Result; + + /** + * Visit a parse tree produced by the `normalize` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNormalize?: (ctx: NormalizeContext) => Result; + + /** + * Visit a parse tree produced by the `extract` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitExtract?: (ctx: ExtractContext) => Result; + + /** + * Visit a parse tree produced by the `parenthesizedExpression` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitParenthesizedExpression?: (ctx: ParenthesizedExpressionContext) => Result; + + /** + * Visit a parse tree produced by the `groupingOperation` + * labeled alternative in `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitGroupingOperation?: (ctx: GroupingOperationContext) => Result; + + /** + * Visit a parse tree produced by the `selectSingle` + * labeled alternative in `ImpalaSqlParser.selectItem`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSelectSingle?: (ctx: SelectSingleContext) => Result; + + /** + * Visit a parse tree produced by the `selectAll` + * labeled alternative in `ImpalaSqlParser.selectItem`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSelectAll?: (ctx: SelectAllContext) => Result; + + /** + * Visit a parse tree produced by the `qualifiedArgument` + * labeled alternative in `ImpalaSqlParser.pathElement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQualifiedArgument?: (ctx: QualifiedArgumentContext) => Result; + + /** + * Visit a parse tree produced by the `unqualifiedArgument` + * labeled alternative in `ImpalaSqlParser.pathElement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnqualifiedArgument?: (ctx: UnqualifiedArgumentContext) => Result; + + /** + * Visit a parse tree produced by the `rolePrincipal` + * labeled alternative in `ImpalaSqlParser.principal`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRolePrincipal?: (ctx: RolePrincipalContext) => Result; + + /** + * Visit a parse tree produced by the `userPrincipal` + * labeled alternative in `ImpalaSqlParser.principal`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUserPrincipal?: (ctx: UserPrincipalContext) => Result; + + /** + * Visit a parse tree produced by the `groupPrincipal` + * labeled alternative in `ImpalaSqlParser.principal`. + * @param ctx the parse tree + * @return the visitor result + */ + visitGroupPrincipal?: (ctx: GroupPrincipalContext) => Result; + + /** + * Visit a parse tree produced by the `predicated` + * labeled alternative in `ImpalaSqlParser.booleanExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPredicated?: (ctx: PredicatedContext) => Result; + + /** + * Visit a parse tree produced by the `logicalNot` + * labeled alternative in `ImpalaSqlParser.booleanExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLogicalNot?: (ctx: LogicalNotContext) => Result; + + /** + * Visit a parse tree produced by the `logicalBinary` + * labeled alternative in `ImpalaSqlParser.booleanExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLogicalBinary?: (ctx: LogicalBinaryContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.program`. + * @param ctx the parse tree + * @return the visitor result + */ + visitProgram?: (ctx: ProgramContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitStatement?: (ctx: StatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.useStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUseStatement?: (ctx: UseStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.createStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateStatement?: (ctx: CreateStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.createTableSelect`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateTableSelect?: (ctx: CreateTableSelectContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.createTableLike`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateTableLike?: (ctx: CreateTableLikeContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.createKuduTableAsSelect`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateKuduTableAsSelect?: (ctx: CreateKuduTableAsSelectContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.createView`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateView?: (ctx: CreateViewContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.createSchema`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateSchema?: (ctx: CreateSchemaContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.createRole`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateRole?: (ctx: CreateRoleContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.createAggregateFunction`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateAggregateFunction?: (ctx: CreateAggregateFunctionContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.createFunction`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateFunction?: (ctx: CreateFunctionContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.alterStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAlterStatement?: (ctx: AlterStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.alterDatabase`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAlterDatabase?: (ctx: AlterDatabaseContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.alterStatsKey`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAlterStatsKey?: (ctx: AlterStatsKeyContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.alterPartitionCache`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAlterPartitionCache?: (ctx: AlterPartitionCacheContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.changeColumnDefine`. + * @param ctx the parse tree + * @return the visitor result + */ + visitChangeColumnDefine?: (ctx: ChangeColumnDefineContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.alterDropSingleColumn`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAlterDropSingleColumn?: (ctx: AlterDropSingleColumnContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.alterTableOwner`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAlterTableOwner?: (ctx: AlterTableOwnerContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.replaceOrAddColumns`. + * @param ctx the parse tree + * @return the visitor result + */ + visitReplaceOrAddColumns?: (ctx: ReplaceOrAddColumnsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.addSingleColumn`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAddSingleColumn?: (ctx: AddSingleColumnContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.alterTableNonKuduOrKuduOnly`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAlterTableNonKuduOrKuduOnly?: (ctx: AlterTableNonKuduOrKuduOnlyContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.addPartitionByRangeOrValue`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAddPartitionByRangeOrValue?: (ctx: AddPartitionByRangeOrValueContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.alterFormat`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAlterFormat?: (ctx: AlterFormatContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.recoverPartitions`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRecoverPartitions?: (ctx: RecoverPartitionsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.dropPartitionByRangeOrValue`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropPartitionByRangeOrValue?: (ctx: DropPartitionByRangeOrValueContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.alterView`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAlterView?: (ctx: AlterViewContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.renameView`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRenameView?: (ctx: RenameViewContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.alterViewOwner`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAlterViewOwner?: (ctx: AlterViewOwnerContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.renameTable`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRenameTable?: (ctx: RenameTableContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.alterUnSetOrSetViewTblproperties`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAlterUnSetOrSetViewTblproperties?: (ctx: AlterUnSetOrSetViewTblpropertiesContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.truncateTableStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTruncateTableStatement?: (ctx: TruncateTableStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.describeStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDescribeStatement?: (ctx: DescribeStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.computeStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitComputeStatement?: (ctx: ComputeStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.computeStats`. + * @param ctx the parse tree + * @return the visitor result + */ + visitComputeStats?: (ctx: ComputeStatsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.computeIncrementalStats`. + * @param ctx the parse tree + * @return the visitor result + */ + visitComputeIncrementalStats?: (ctx: ComputeIncrementalStatsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.dropStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropStatement?: (ctx: DropStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.dropSchema`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropSchema?: (ctx: DropSchemaContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.dropView`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropView?: (ctx: DropViewContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.dropTable`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropTable?: (ctx: DropTableContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.dropIncrementalStats`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropIncrementalStats?: (ctx: DropIncrementalStatsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.dropFunction`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropFunction?: (ctx: DropFunctionContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.dropRole`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDropRole?: (ctx: DropRoleContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.grantStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitGrantStatement?: (ctx: GrantStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.grantRole`. + * @param ctx the parse tree + * @return the visitor result + */ + visitGrantRole?: (ctx: GrantRoleContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.grant`. + * @param ctx the parse tree + * @return the visitor result + */ + visitGrant?: (ctx: GrantContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.revokeStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRevokeStatement?: (ctx: RevokeStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.revokeRole`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRevokeRole?: (ctx: RevokeRoleContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.revoke`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRevoke?: (ctx: RevokeContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.insertStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInsertStatement?: (ctx: InsertStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.deleteStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDeleteStatement?: (ctx: DeleteStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.delete`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDelete?: (ctx: DeleteContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.deleteTableRef`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDeleteTableRef?: (ctx: DeleteTableRefContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.updateStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUpdateStatement?: (ctx: UpdateStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.upsertStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUpsertStatement?: (ctx: UpsertStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowStatement?: (ctx: ShowStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showSchemas`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowSchemas?: (ctx: ShowSchemasContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showTables`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowTables?: (ctx: ShowTablesContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showFunctions`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowFunctions?: (ctx: ShowFunctionsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showCreateTable`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowCreateTable?: (ctx: ShowCreateTableContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showCreateView`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowCreateView?: (ctx: ShowCreateViewContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showTableStats`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowTableStats?: (ctx: ShowTableStatsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showColumnStats`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowColumnStats?: (ctx: ShowColumnStatsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showPartitions`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowPartitions?: (ctx: ShowPartitionsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showFiles`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowFiles?: (ctx: ShowFilesContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showRoles`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowRoles?: (ctx: ShowRolesContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showRoleGrant`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowRoleGrant?: (ctx: ShowRoleGrantContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showGrants`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowGrants?: (ctx: ShowGrantsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showDatabaseGrant`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowDatabaseGrant?: (ctx: ShowDatabaseGrantContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showTableGrant`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowTableGrant?: (ctx: ShowTableGrantContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.showColumnGrant`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShowColumnGrant?: (ctx: ShowColumnGrantContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.addCommentStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAddCommentStatement?: (ctx: AddCommentStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.addDatabaseComments`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAddDatabaseComments?: (ctx: AddDatabaseCommentsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.addTableComments`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAddTableComments?: (ctx: AddTableCommentsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.addColumnComments`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAddColumnComments?: (ctx: AddColumnCommentsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.explainStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitExplainStatement?: (ctx: ExplainStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.setStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSetStatement?: (ctx: SetStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.shutdownStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitShutdownStatement?: (ctx: ShutdownStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.invalidateMetaStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInvalidateMetaStatement?: (ctx: InvalidateMetaStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.loadDataStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLoadDataStatement?: (ctx: LoadDataStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.refreshStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRefreshStatement?: (ctx: RefreshStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.refreshMeta`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRefreshMeta?: (ctx: RefreshMetaContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.refreshAuth`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRefreshAuth?: (ctx: RefreshAuthContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.refreshFunction`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRefreshFunction?: (ctx: RefreshFunctionContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.ifExists`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIfExists?: (ctx: IfExistsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.ifNotExists`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIfNotExists?: (ctx: IfNotExistsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.tableNameCreate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTableNameCreate?: (ctx: TableNameCreateContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.databaseNameCreate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDatabaseNameCreate?: (ctx: DatabaseNameCreateContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.viewNameCreate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitViewNameCreate?: (ctx: ViewNameCreateContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.functionNameCreate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFunctionNameCreate?: (ctx: FunctionNameCreateContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.columnNamePathCreate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColumnNamePathCreate?: (ctx: ColumnNamePathCreateContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.databaseNamePath`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDatabaseNamePath?: (ctx: DatabaseNamePathContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.tableNamePath`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTableNamePath?: (ctx: TableNamePathContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.viewNamePath`. + * @param ctx the parse tree + * @return the visitor result + */ + visitViewNamePath?: (ctx: ViewNamePathContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.functionNamePath`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFunctionNamePath?: (ctx: FunctionNamePathContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.columnNamePath`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColumnNamePath?: (ctx: ColumnNamePathContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.tableOrViewPath`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTableOrViewPath?: (ctx: TableOrViewPathContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.createCommonItem`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateCommonItem?: (ctx: CreateCommonItemContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.assignmentList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAssignmentList?: (ctx: AssignmentListContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.assignmentItem`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAssignmentItem?: (ctx: AssignmentItemContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.viewColumns`. + * @param ctx the parse tree + * @return the visitor result + */ + visitViewColumns?: (ctx: ViewColumnsContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.queryStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQueryStatement?: (ctx: QueryStatementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.with`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWith?: (ctx: WithContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.constraintSpecification`. + * @param ctx the parse tree + * @return the visitor result + */ + visitConstraintSpecification?: (ctx: ConstraintSpecificationContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.foreignKeySpecification`. + * @param ctx the parse tree + * @return the visitor result + */ + visitForeignKeySpecification?: (ctx: ForeignKeySpecificationContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.columnDefinition`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColumnDefinition?: (ctx: ColumnDefinitionContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.kuduTableElement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitKuduTableElement?: (ctx: KuduTableElementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.kuduColumnDefinition`. + * @param ctx the parse tree + * @return the visitor result + */ + visitKuduColumnDefinition?: (ctx: KuduColumnDefinitionContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.columnSpecWithKudu`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColumnSpecWithKudu?: (ctx: ColumnSpecWithKuduContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.createColumnSpecWithKudu`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateColumnSpecWithKudu?: (ctx: CreateColumnSpecWithKuduContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.kuduAttributes`. + * @param ctx the parse tree + * @return the visitor result + */ + visitKuduAttributes?: (ctx: KuduAttributesContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.kuduStorageAttr`. + * @param ctx the parse tree + * @return the visitor result + */ + visitKuduStorageAttr?: (ctx: KuduStorageAttrContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.statsKey`. + * @param ctx the parse tree + * @return the visitor result + */ + visitStatsKey?: (ctx: StatsKeyContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.fileFormat`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFileFormat?: (ctx: FileFormatContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.kuduPartitionClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitKuduPartitionClause?: (ctx: KuduPartitionClauseContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.hashClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitHashClause?: (ctx: HashClauseContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.rangeClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRangeClause?: (ctx: RangeClauseContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.kuduPartitionSpec`. + * @param ctx the parse tree + * @return the visitor result + */ + visitKuduPartitionSpec?: (ctx: KuduPartitionSpecContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.cacheSpec`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCacheSpec?: (ctx: CacheSpecContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.rangeOperator`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRangeOperator?: (ctx: RangeOperatorContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.partitionCol`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPartitionCol?: (ctx: PartitionColContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.likeClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLikeClause?: (ctx: LikeClauseContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.properties`. + * @param ctx the parse tree + * @return the visitor result + */ + visitProperties?: (ctx: PropertiesContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.partitionedBy`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPartitionedBy?: (ctx: PartitionedByContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.sortedBy`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSortedBy?: (ctx: SortedByContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.rowFormat`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRowFormat?: (ctx: RowFormatContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.property`. + * @param ctx the parse tree + * @return the visitor result + */ + visitProperty?: (ctx: PropertyContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.queryNoWith`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQueryNoWith?: (ctx: QueryNoWithContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.queryTerm`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQueryTerm?: (ctx: QueryTermContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.queryPrimary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQueryPrimary?: (ctx: QueryPrimaryContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.sortItem`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSortItem?: (ctx: SortItemContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.querySpecification`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQuerySpecification?: (ctx: QuerySpecificationContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.groupBy`. + * @param ctx the parse tree + * @return the visitor result + */ + visitGroupBy?: (ctx: GroupByContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.groupingElement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitGroupingElement?: (ctx: GroupingElementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.groupingSet`. + * @param ctx the parse tree + * @return the visitor result + */ + visitGroupingSet?: (ctx: GroupingSetContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.namedQuery`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNamedQuery?: (ctx: NamedQueryContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.setQuantifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSetQuantifier?: (ctx: SetQuantifierContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.selectItem`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSelectItem?: (ctx: SelectItemContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.relation`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRelation?: (ctx: RelationContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.joinType`. + * @param ctx the parse tree + * @return the visitor result + */ + visitJoinType?: (ctx: JoinTypeContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.joinCriteria`. + * @param ctx the parse tree + * @return the visitor result + */ + visitJoinCriteria?: (ctx: JoinCriteriaContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.sampledRelation`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSampledRelation?: (ctx: SampledRelationContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.sampleType`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSampleType?: (ctx: SampleTypeContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.aliasedRelation`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAliasedRelation?: (ctx: AliasedRelationContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.columnAliases`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColumnAliases?: (ctx: ColumnAliasesContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.createColumnAliases`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreateColumnAliases?: (ctx: CreateColumnAliasesContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.relationPrimary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRelationPrimary?: (ctx: RelationPrimaryContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.subQueryRelation`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSubQueryRelation?: (ctx: SubQueryRelationContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.unnest`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUnnest?: (ctx: UnnestContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.parenthesizedRelation`. + * @param ctx the parse tree + * @return the visitor result + */ + visitParenthesizedRelation?: (ctx: ParenthesizedRelationContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.columnItem`. + * @param ctx the parse tree + * @return the visitor result + */ + visitColumnItem?: (ctx: ColumnItemContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitExpression?: (ctx: ExpressionContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.booleanExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBooleanExpression?: (ctx: BooleanExpressionContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.predicate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPredicate?: (ctx: PredicateContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.valueExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitValueExpression?: (ctx: ValueExpressionContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.primaryExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPrimaryExpression?: (ctx: PrimaryExpressionContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.stringLiteral`. + * @param ctx the parse tree + * @return the visitor result + */ + visitStringLiteral?: (ctx: StringLiteralContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.comparisonOperator`. + * @param ctx the parse tree + * @return the visitor result + */ + visitComparisonOperator?: (ctx: ComparisonOperatorContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.comparisonQuantifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitComparisonQuantifier?: (ctx: ComparisonQuantifierContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.booleanValue`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBooleanValue?: (ctx: BooleanValueContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.interval`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInterval?: (ctx: IntervalContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.intervalField`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIntervalField?: (ctx: IntervalFieldContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.normalForm`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNormalForm?: (ctx: NormalFormContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.type`. + * @param ctx the parse tree + * @return the visitor result + */ + visitType?: (ctx: TypeContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.typeParameter`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTypeParameter?: (ctx: TypeParameterContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.baseType`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBaseType?: (ctx: BaseTypeContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.whenClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWhenClause?: (ctx: WhenClauseContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.filter`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFilter?: (ctx: FilterContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.over`. + * @param ctx the parse tree + * @return the visitor result + */ + visitOver?: (ctx: OverContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.windowFrame`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWindowFrame?: (ctx: WindowFrameContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.frameBound`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFrameBound?: (ctx: FrameBoundContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.pathElement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPathElement?: (ctx: PathElementContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.pathSpecification`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPathSpecification?: (ctx: PathSpecificationContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.privilege`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPrivilege?: (ctx: PrivilegeContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.objectType`. + * @param ctx the parse tree + * @return the visitor result + */ + visitObjectType?: (ctx: ObjectTypeContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.qualifiedName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQualifiedName?: (ctx: QualifiedNameContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.principal`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPrincipal?: (ctx: PrincipalContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.identifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIdentifier?: (ctx: IdentifierContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.number`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNumber?: (ctx: NumberContext) => Result; + + /** + * Visit a parse tree produced by `ImpalaSqlParser.nonReserved`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNonReserved?: (ctx: NonReservedContext) => Result; +} + diff --git a/src/parser/impala.ts b/src/parser/impala.ts new file mode 100644 index 0000000..001da3d --- /dev/null +++ b/src/parser/impala.ts @@ -0,0 +1,139 @@ +import { Token } from 'antlr4ts'; +import { CandidatesCollection } from 'antlr4-c3'; +import { ImpalaSqlLexer } from '../lib/impala/ImpalaSqlLexer'; +import { ImpalaSqlParser, ProgramContext, StatementContext } from '../lib/impala/ImpalaSqlParser'; +import BasicParser from './common/basicParser'; +import { ImpalaSqlParserListener } from '../lib/impala/ImpalaSqlParserListener'; +import { SyntaxContextType, Suggestions, SyntaxSuggestion } from './common/basic-parser-types'; + +export default class ImpalaSQL extends BasicParser< + ImpalaSqlLexer, + ProgramContext, + ImpalaSqlParser +> { + protected createLexerFormCharStream(charStreams) { + const lexer = new ImpalaSqlLexer(charStreams); + return lexer; + } + + protected createParserFromTokenStream(tokenStream) { + return new ImpalaSqlParser(tokenStream); + } + + protected preferredRules: Set = new Set([ + ImpalaSqlParser.RULE_functionNameCreate, + ImpalaSqlParser.RULE_tableNameCreate, + ImpalaSqlParser.RULE_viewNameCreate, + ImpalaSqlParser.RULE_databaseNameCreate, + ImpalaSqlParser.RULE_columnNamePathCreate, + ImpalaSqlParser.RULE_tableNamePath, + ImpalaSqlParser.RULE_functionNamePath, + ImpalaSqlParser.RULE_viewNamePath, + ImpalaSqlParser.RULE_databaseNamePath, + ImpalaSqlParser.RULE_columnNamePath, + ]); + + protected get splitListener() { + return new ImpalaSqlSplitListener(); + } + + protected processCandidates( + candidates: CandidatesCollection, + allTokens: Token[], + caretTokenIndex: number, + tokenIndexOffset: number + ): Suggestions { + const originalSyntaxSuggestions: SyntaxSuggestion[] = []; + const keywords: string[] = []; + for (let candidate of candidates.rules) { + const [ruleType, candidateRule] = candidate; + const startTokenIndex = candidateRule.startTokenIndex + tokenIndexOffset; + const tokenRanges = allTokens.slice( + startTokenIndex, + caretTokenIndex + tokenIndexOffset + 1 + ); + + let syntaxContextType: SyntaxContextType; + switch (ruleType) { + case ImpalaSqlParser.RULE_functionNameCreate: { + syntaxContextType = SyntaxContextType.FUNCTION_CREATE; + break; + } + case ImpalaSqlParser.RULE_tableNameCreate: { + syntaxContextType = SyntaxContextType.TABLE_CREATE; + break; + } + case ImpalaSqlParser.RULE_databaseNameCreate: { + syntaxContextType = SyntaxContextType.DATABASE_CREATE; + break; + } + case ImpalaSqlParser.RULE_viewNameCreate: { + syntaxContextType = SyntaxContextType.VIEW_CREATE; + break; + } + case ImpalaSqlParser.RULE_columnNamePathCreate: { + syntaxContextType = SyntaxContextType.COLUMN_CREATE; + break; + } + case ImpalaSqlParser.RULE_databaseNamePath: { + syntaxContextType = SyntaxContextType.DATABASE; + break; + } + case ImpalaSqlParser.RULE_tableNamePath: { + syntaxContextType = SyntaxContextType.TABLE; + break; + } + case ImpalaSqlParser.RULE_viewNamePath: { + syntaxContextType = SyntaxContextType.VIEW; + break; + } + case ImpalaSqlParser.RULE_functionNamePath: { + syntaxContextType = SyntaxContextType.FUNCTION; + break; + } + case ImpalaSqlParser.RULE_columnNamePath: { + syntaxContextType = SyntaxContextType.COLUMN; + } + default: + break; + } + + if (syntaxContextType) { + originalSyntaxSuggestions.push({ + syntaxContextType, + wordRanges: tokenRanges, + }); + } + } + + for (let candidate of candidates.tokens) { + const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]); + const displayName = this._parser.vocabulary.getDisplayName(candidate[0]); + if (symbolicName && symbolicName.startsWith('KW_')) { + const keyword = + displayName.startsWith("'") && displayName.endsWith("'") + ? displayName.slice(1, -1) + : displayName; + keywords.push(keyword); + } + } + return { + syntax: originalSyntaxSuggestions, + keywords, + }; + } +} + +export class ImpalaSqlSplitListener implements ImpalaSqlParserListener { + private _statementContext: StatementContext[] = []; + + exitStatement = (ctx: StatementContext) => { + this._statementContext.push(ctx); + }; + + enterStatement = (ctx: StatementContext) => {}; + + get statementsContext() { + return this._statementContext; + } +} diff --git a/src/parser/index.ts b/src/parser/index.ts index bc0d133..03e3952 100644 --- a/src/parser/index.ts +++ b/src/parser/index.ts @@ -5,3 +5,4 @@ export { default as FlinkSQL } from './flinksql'; export { default as SparkSQL } from './spark'; export { default as PostgresSQL } from './pgsql'; export { default as TrinoSQL } from './trinosql'; +export { default as ImpalaSQL } from './impala'; diff --git a/test/parser/impala/lexer.test.ts b/test/parser/impala/lexer.test.ts new file mode 100644 index 0000000..6d2196b --- /dev/null +++ b/test/parser/impala/lexer.test.ts @@ -0,0 +1,12 @@ +import ImpalaSQL from '../../../src/parser/impala'; + +describe('ImpalaSQL Lexer tests', () => { + const parser = new ImpalaSQL(); + + const sql = 'SELECT * FROM table1'; + const tokens = parser.getAllTokens(sql); + + test('token counts', () => { + expect(tokens.length).toBe(7); + }); +}); diff --git a/test/parser/impala/listener.test.ts b/test/parser/impala/listener.test.ts new file mode 100644 index 0000000..c727772 --- /dev/null +++ b/test/parser/impala/listener.test.ts @@ -0,0 +1,24 @@ +import impalaSQL from '../../../src/parser/impala'; +import { ImpalaSqlParserListener } from '../../../src/lib/impala/ImpalaSqlParserListener'; +import { ParseTreeListener } from 'antlr4ts/tree'; + +describe('impala SQL Listener Tests', () => { + const expectTableName = 'user1'; + const sql = `select id,name,sex from ${expectTableName};`; + const parser = new impalaSQL(); + + const parseTree = parser.parse(sql); + + test('Listener enterTableName', async () => { + let result = ''; + class MyListener implements ImpalaSqlParserListener { + enterTableNamePath = (ctx): void => { + result = ctx.text.toLowerCase(); + }; + } + const listenTableName = new MyListener(); + + await parser.listen(listenTableName as ParseTreeListener, parseTree); + expect(result).toBe(expectTableName); + }); +}); diff --git a/test/parser/impala/suggestion/fixtures/syntaxSuggestion.sql b/test/parser/impala/suggestion/fixtures/syntaxSuggestion.sql new file mode 100644 index 0000000..3508ee9 --- /dev/null +++ b/test/parser/impala/suggestion/fixtures/syntaxSuggestion.sql @@ -0,0 +1,45 @@ +SELECT * FROM cat.a; + +SELECT name, calculate_age(birthdate) AS age FROM students; + +ALTER DATABASE cat; + +ALTER TABLE my_table CHANGE COLUMN age; + +ALTER VIEW my_view; + +DROP VIEW v; + +DROP DATABASE my_db; + +DROP TABLE my_table; + +DROP FUNCTION my_func; + +DELETE FROM my_table WHERE col1 LIKE 'prefix%'; + +CREATE VIEW cv; + +CREATE TABLE cat.db ; + +CREATE FUNCTION fnc; + +CREATE DATABASE FIRST_DB; + +SHOW TABLES in cat; + +SHOW COLUMN STATS vie; + +SHOW CREATE TABLE tb1; + +SHOW CREATE VIEW v1; + +SELECT id GROUP BY id; + +SELECT id ORDER BY id; + +CREATE TABLE census_data (last_name STRING); + +ALTER TABLE my_table ADD COLUMN age INT COMMENT 'Updated Age'; + +CREATE TABLE kudu_no_partition_by_clause (id bigint PRIMARY KEY, s STRING, b BOOLEAN ) STORED AS KUDU; \ No newline at end of file diff --git a/test/parser/impala/suggestion/fixtures/tokenSuggestion.sql b/test/parser/impala/suggestion/fixtures/tokenSuggestion.sql new file mode 100644 index 0000000..e27a227 --- /dev/null +++ b/test/parser/impala/suggestion/fixtures/tokenSuggestion.sql @@ -0,0 +1,9 @@ +ALTER ; + +CREATE ; + +DROP ; + +INSERT ; + +SHOW ; diff --git a/test/parser/impala/suggestion/syntaxSuggestion.test.ts b/test/parser/impala/suggestion/syntaxSuggestion.test.ts new file mode 100644 index 0000000..a00aa1c --- /dev/null +++ b/test/parser/impala/suggestion/syntaxSuggestion.test.ts @@ -0,0 +1,349 @@ +import fs from 'fs'; +import path from 'path'; +import { CaretPosition, SyntaxContextType } from '../../../../src/parser/common/basic-parser-types'; +import ImpalaSQL from '../../../../src/parser/impala'; + +const syntaxSql = fs.readFileSync( + path.join(__dirname, 'fixtures', 'syntaxSuggestion.sql'), + 'utf-8' +); + +describe('Impala SQL Syntax Suggestion', () => { + const parser = new ImpalaSQL(); + + test('Select table', () => { + const pos: CaretPosition = { + lineNumber: 1, + column: 20, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.TABLE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['cat', '.', 'a']); + }); + + test('Function call', () => { + const pos: CaretPosition = { + lineNumber: 3, + column: 27, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.FUNCTION + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['calculate_age']); + }); + + test('Alter database', () => { + const pos: CaretPosition = { + lineNumber: 5, + column: 19, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.DATABASE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['cat']); + }); + + test('Alter table', () => { + const pos: CaretPosition = { + lineNumber: 7, + column: 21, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.TABLE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['my_table']); + }); + + test('Alter table column', () => { + const pos: CaretPosition = { + lineNumber: 7, + column: 39, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['age']); + }); + + test('Alter view', () => { + const pos: CaretPosition = { + lineNumber: 9, + column: 19, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.VIEW + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['my_view']); + }); + + test('Drop view', () => { + const pos: CaretPosition = { + lineNumber: 11, + column: 12, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.VIEW + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['v']); + }); + + test('Drop database', () => { + const pos: CaretPosition = { + lineNumber: 13, + column: 20, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.DATABASE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['my_db']); + }); + + test('Drop table', () => { + const pos: CaretPosition = { + lineNumber: 15, + column: 20, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.TABLE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['my_table']); + }); + + test('Drop function', () => { + const pos: CaretPosition = { + lineNumber: 17, + column: 22, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.FUNCTION + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['my_func']); + }); + + test('DELETE table', () => { + const pos: CaretPosition = { + lineNumber: 19, + column: 21, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.TABLE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['my_table']); + }); + + test('Create view', () => { + const pos: CaretPosition = { + lineNumber: 21, + column: 15, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.VIEW_CREATE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['cv']); + }); + + test('Create table', () => { + const pos: CaretPosition = { + lineNumber: 23, + column: 20, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.TABLE_CREATE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['cat', '.', 'db']); + }); + + test('Create Function', () => { + const pos: CaretPosition = { + lineNumber: 25, + column: 20, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.FUNCTION_CREATE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['fnc']); + }); + + test('Create database', () => { + const pos: CaretPosition = { + lineNumber: 27, + column: 25, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.DATABASE_CREATE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['FIRST_DB']); + }); + + test('Show tables in', () => { + const pos: CaretPosition = { + lineNumber: 29, + column: 19, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.TABLE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['cat']); + }); + + test('Show column stats table', () => { + const pos: CaretPosition = { + lineNumber: 31, + column: 22, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.TABLE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['vie']); + }); + + test('Show create table', () => { + const pos: CaretPosition = { + lineNumber: 33, + column: 22, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.TABLE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['tb1']); + }); + + test('Show create view', () => { + const pos: CaretPosition = { + lineNumber: 35, + column: 20, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.VIEW + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['v1']); + }); + + test('Select group by', () => { + const pos: CaretPosition = { + lineNumber: 37, + column: 22, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['id']); + }); + + test('Select order by', () => { + const pos: CaretPosition = { + lineNumber: 39, + column: 22, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['id']); + }); + + test('Create Table column', () => { + const pos: CaretPosition = { + lineNumber: 41, + column: 36, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN_CREATE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['last_name']); + }); + + test('Alert Table column', () => { + const pos: CaretPosition = { + lineNumber: 43, + column: 36, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN_CREATE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['age']); + }); + + test('Create Table kudu', () => { + const pos: CaretPosition = { + lineNumber: 45, + column: 45, + }; + const syntaxes = parser.getSuggestionAtCaretPosition(syntaxSql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN_CREATE + ); + + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['id']); + }); +}); diff --git a/test/parser/impala/suggestion/tokenSuggestion.test.ts b/test/parser/impala/suggestion/tokenSuggestion.test.ts new file mode 100644 index 0000000..14b8bfe --- /dev/null +++ b/test/parser/impala/suggestion/tokenSuggestion.test.ts @@ -0,0 +1,109 @@ +import fs from 'fs'; +import path from 'path'; +import { CaretPosition } from '../../../../src/parser/common/basic-parser-types'; +import impalaSQL from '../../../../src/parser/impala'; +import { commentOtherLine } from '../../../helper'; + +const tokenSql = fs.readFileSync(path.join(__dirname, 'fixtures', 'tokenSuggestion.sql'), 'utf-8'); + +describe('Impala SQL Token Suggestion', () => { + const parser = new impalaSQL(); + + test('After ALTER', () => { + const pos: CaretPosition = { + lineNumber: 1, + column: 7, + }; + const suggestion = parser.getSuggestionAtCaretPosition(tokenSql, pos)?.keywords; + + expect(suggestion).toEqual(['TABLE', 'VIEW', 'DATABASE']); + }); + + test('After CREATE', () => { + const pos: CaretPosition = { + lineNumber: 3, + column: 8, + }; + const suggestion = parser.getSuggestionAtCaretPosition( + commentOtherLine(tokenSql, pos.lineNumber), + pos + )?.keywords; + + expect(suggestion).toEqual([ + 'TABLE', + 'EXTERNAL', + 'VIEW', + 'FUNCTION', + 'AGGREGATE', + 'ROLE', + 'DATABASE', + 'SCHEMA', + ]); + }); + + test('After DROP', () => { + const pos: CaretPosition = { + lineNumber: 5, + column: 6, + }; + const suggestion = parser.getSuggestionAtCaretPosition( + commentOtherLine(tokenSql, pos.lineNumber), + pos + )?.keywords; + + expect(suggestion).toEqual([ + 'DATABASE', + 'SCHEMA', + 'TABLE', + 'VIEW', + 'STATS', + 'INCREMENTAL', + 'FUNCTION', + 'AGGREGATE', + 'ROLE', + ]); + }); + + test('After INSERT', () => { + const pos: CaretPosition = { + lineNumber: 7, + column: 8, + }; + const suggestion = parser.getSuggestionAtCaretPosition( + commentOtherLine(tokenSql, pos.lineNumber), + pos + )?.keywords; + + expect(suggestion).toEqual(['INTO', 'OVERWRITE']); + }); + + test('After SHOW', () => { + const pos: CaretPosition = { + lineNumber: 9, + column: 6, + }; + const suggestion = parser.getSuggestionAtCaretPosition( + commentOtherLine(tokenSql, pos.lineNumber), + pos + )?.keywords; + + expect(suggestion).toEqual([ + 'DATABASES', + 'SCHEMAS', + 'TABLES', + 'FUNCTIONS', + 'ANALYTIC', + 'AGGREGATE', + 'CREATE', + 'TABLE', + 'COLUMN', + 'PARTITIONS', + 'RANGE', + 'FILES', + 'GRANT', + 'ROLE', + 'ROLES', + 'CURRENT', + ]); + }); +}); diff --git a/test/parser/impala/syntax/alterStatement.test.ts b/test/parser/impala/syntax/alterStatement.test.ts new file mode 100644 index 0000000..c17bcbe --- /dev/null +++ b/test/parser/impala/syntax/alterStatement.test.ts @@ -0,0 +1,34 @@ +import ImpalaSQL from '../../../../src/parser/impala'; +import { readSQL } from '../../../helper'; + +const parser = new ImpalaSQL(); + +const features = { + tables: readSQL(__dirname, 'alter_table.sql'), + dbs: readSQL(__dirname, 'alter_db.sql'), + views: readSQL(__dirname, 'alter_view.sql'), +}; + +describe('ImpalaSQL Alter Syntax Tests', () => { + describe('ALTER TABLE', () => { + features.tables.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('ALTER DATABASE', () => { + features.dbs.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('ALTER VIEW', () => { + features.views.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); +}); diff --git a/test/parser/impala/syntax/creataStatement.test.ts b/test/parser/impala/syntax/creataStatement.test.ts new file mode 100644 index 0000000..d5149aa --- /dev/null +++ b/test/parser/impala/syntax/creataStatement.test.ts @@ -0,0 +1,50 @@ +import ImpalaSQL from '../../../../src/parser/impala'; +import { readSQL } from '../../../helper'; + +const parser = new ImpalaSQL(); + +const features = { + dbs: readSQL(__dirname, 'create_db.sql'), + functions: readSQL(__dirname, 'create_function.sql'), + roles: readSQL(__dirname, 'create_role.sql'), + tables: readSQL(__dirname, 'create_table.sql'), + views: readSQL(__dirname, 'create_view.sql'), +}; + +describe('ImpalaSQL Create Syntax Tests', () => { + describe('CREATE DB', () => { + features.dbs.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('CREATE FUNCTION', () => { + features.functions.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('CREATE ROLE', () => { + features.roles.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('CREATE TABLE', () => { + features.tables.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('CREATE VIEW', () => { + features.views.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); +}); diff --git a/test/parser/impala/syntax/delete.test.ts b/test/parser/impala/syntax/delete.test.ts new file mode 100644 index 0000000..0dd44e6 --- /dev/null +++ b/test/parser/impala/syntax/delete.test.ts @@ -0,0 +1,18 @@ +import ImpalaSQL from '../../../../src/parser/impala'; +import { readSQL } from '../../../helper'; + +const parser = new ImpalaSQL(); + +const features = { + deletes: readSQL(__dirname, 'delete.sql'), +}; + +describe('ImpalaSQL Delete Syntax Tests', () => { + describe('DELETE', () => { + features.deletes.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); +}); diff --git a/test/parser/impala/syntax/dropStatement.test.ts b/test/parser/impala/syntax/dropStatement.test.ts new file mode 100644 index 0000000..28f689c --- /dev/null +++ b/test/parser/impala/syntax/dropStatement.test.ts @@ -0,0 +1,58 @@ +import ImpalaSQL from '../../../../src/parser/impala'; +import { readSQL } from '../../../helper'; + +const parser = new ImpalaSQL(); + +const features = { + dbs: readSQL(__dirname, 'drop_db.sql'), + functions: readSQL(__dirname, 'drop_function.sql'), + roles: readSQL(__dirname, 'drop_role.sql'), + stats: readSQL(__dirname, 'drop_stats.sql'), + tables: readSQL(__dirname, 'drop_table.sql'), + views: readSQL(__dirname, 'drop_view.sql'), +}; + +describe('ImpalaSQL Drop Syntax Tests', () => { + describe('DROP DATABASE', () => { + features.dbs.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('DROP FUNCTION', () => { + features.functions.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('DROP ROLE', () => { + features.roles.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('DROP STATS', () => { + features.stats.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('DROP TABLE', () => { + features.tables.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('DROP VIEW', () => { + features.views.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); +}); diff --git a/test/parser/impala/syntax/fixtures/alter_db.sql b/test/parser/impala/syntax/fixtures/alter_db.sql new file mode 100644 index 0000000..46eac48 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/alter_db.sql @@ -0,0 +1,2 @@ +-- ALTER DATABASE database_name SET OWNER USER user_name; +ALTER DATABASE my_db SET OWNER USER 'impala'; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/alter_table.sql b/test/parser/impala/syntax/fixtures/alter_table.sql new file mode 100644 index 0000000..0ce5c17 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/alter_table.sql @@ -0,0 +1,133 @@ +-- ALTER TABLE [old_db_name.]old_table_name RENAME TO [new_db_name.]new_table_name +ALTER TABLE old_table_name RENAME TO new_table_name; +ALTER TABLE old_db_name.old_table_name RENAME TO new_table_name; +ALTER TABLE old_table_name RENAME TO new_db_name.new_table_name; +ALTER TABLE old_db_name.old_table_name RENAME TO new_db_name.new_table_name; + +-- ALTER TABLE name ADD [IF NOT EXISTS] COLUMNS (col_spec[, col_spec ...]) +ALTER TABLE my_table ADD COLUMNS (id INT COMMENT 'Identifier', name STRING COMMENT 'Name'); +ALTER TABLE my_table ADD IF NOT EXISTS COLUMNS (age INT COMMENT 'Age'); +ALTER TABLE my_table ADD COLUMNS (email STRING COMMENT 'Email'); + +-- ALTER TABLE name REPLACE COLUMNS (col_spec[, col_spec ...]) +ALTER TABLE my_table REPLACE COLUMNS (age INT COMMENT 'Updated Age'); +ALTER TABLE my_table REPLACE COLUMNS (email STRING COMMENT 'Updated Email', address STRING COMMENT 'Updated Address'); + +-- ALTER TABLE name ADD COLUMN [IF NOT EXISTS] col_spec +ALTER TABLE my_table ADD COLUMN age INT COMMENT 'Updated Age'; +ALTER TABLE my_table ADD COLUMN IF NOT EXISTS age INT COMMENT 'Updated Age'; + +-- ALTER TABLE name DROP [COLUMN] column_name +ALTER TABLE my_table DROP COLUMN column_name; +ALTER TABLE my_table DROP column_name; + +-- ALTER TABLE name CHANGE column_name col_spec +ALTER TABLE my_table CHANGE COLUMN age INT COMMENT 'Updated Age'; + +-- ALTER TABLE name SET OWNER USER user_name +ALTER TABLE my_table SET OWNER USER user_name; + +/* Kudu tables only. +ALTER TABLE name ALTER [COLUMN] column_name + { SET kudu_storage_attr attr_value + | DROP DEFAULT } */ +ALTER TABLE my_table ALTER COLUMN size SET BLOCK_SIZE 1024 ; +ALTER TABLE my_table ALTER COLUMN id SET DEFAULT 0 ; +ALTER TABLE my_table ALTER COLUMN name SET ENCODING 'plain' ; +ALTER TABLE my_table ALTER COLUMN address SET COMPRESSION 'lz4'; +ALTER TABLE my_table ALTER COLUMN id DROP DEFAULT; + +/* Non-Kudu tables only. +ALTER TABLE name ALTER [COLUMN] column_name + SET COMMENT 'comment_text' */ +ALTER TABLE my_table ALTER age SET COMMENT '年龄'; +ALTER TABLE my_table ALTER COLUMN age SET COMMENT '年龄'; + +/* ALTER TABLE name ADD [IF NOT EXISTS] PARTITION (partition_spec) + [location_spec] + [cache_spec] */ +ALTER TABLE my_table ADD PARTITION (date = '2023-01-01'); +ALTER TABLE my_table ADD IF NOT EXISTS PARTITION (date = '2023-01-01'); +ALTER TABLE my_table ADD PARTITION (country = 'USA') LOCATION '/path/to/partition'; +ALTER TABLE my_table ADD IF NOT EXISTS PARTITION (category = 'Books') LOCATION '/path/to/books_partition'; +ALTER TABLE my_table ADD PARTITION (date = '2023-01-01') CACHED IN 'pool_name' WITH REPLICATION = 3; +ALTER TABLE my_table ADD IF NOT EXISTS PARTITION (date = '2023-01-01') CACHED IN 'pool_name' WITH REPLICATION = 3; +ALTER TABLE my_table ADD PARTITION (country = 'USA') UNCACHED; +ALTER TABLE my_table ADD IF NOT EXISTS PARTITION (country = 'USA') UNCACHED; + +-- ALTER TABLE name ADD [IF NOT EXISTS] RANGE PARTITION kudu_partition_spec +ALTER TABLE my_table ADD RANGE PARTITION VALUE = 100; +ALTER TABLE my_table ADD IF NOT EXISTS RANGE PARTITION 10 < VALUES < 20; + + +/* ALTER TABLE name DROP [IF EXISTS] PARTITION (partition_spec) + [PURGE] */ +ALTER TABLE my_table DROP PARTITION (date = '2023-01-01'); +ALTER TABLE my_table DROP IF EXISTS PARTITION (name = 'impala'); + +-- ALTER TABLE name DROP [IF EXISTS] RANGE PARTITION kudu_partition_spec +ALTER TABLE my_table DROP RANGE PARTITION VALUE != 100; +ALTER TABLE my_table DROP IF EXISTS RANGE PARTITION 10 >= VALUES < 20; + +-- ALTER TABLE name RECOVER PARTITIONS +ALTER TABLE my_table RECOVER PARTITIONS + +/* ALTER TABLE name [PARTITION (partition_spec)] + SET { FILEFORMAT file_format + | ROW FORMAT row_format + | LOCATION 'hdfs_path_of_directory' + | TBLPROPERTIES (table_properties) + | SERDEPROPERTIES (serde_properties) } */ +ALTER TABLE my_table SET FILEFORMAT parquet ; +ALTER TABLE my_table PARTITION (date = '2023-01-01') SET FILEFORMAT orc; +ALTER TABLE my_table SET ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n'; +ALTER TABLE my_table SET LOCATION '/path/to/new_location'; +ALTER TABLE my_table PARTITION (region = 'Europe') SET LOCATION '/path/to/europe_partition'; +ALTER TABLE my_table SET TBLPROPERTIES ('comment' = 'This is a table'); +ALTER TABLE my_table PARTITION (category = 'Books') SET TBLPROPERTIES ('compression' = 'gzip'); +ALTER TABLE my_table SET SERDEPROPERTIES ('field.delim' = '|'); +ALTER TABLE my_table PARTITION (date = '2023-01-01') SET SERDEPROPERTIES ('serialization.null.format' = '\N'); + +/* ALTER TABLE name colname + ('statsKey'='val', ...) */ +alter table t1 set column stats x ('numDVs'='2','numNulls'='0'); +alter table t1 set column stats s ('numdvs'='3','maxsize'='4'); + +-- ALTER TABLE name [PARTITION (partition_spec)] SET { CACHED IN 'pool_name' [WITH REPLICATION = integer] | UNCACHED } +ALTER TABLE my_table SET CACHED IN 'pool_name'; +ALTER TABLE my_table PARTITION (date = '2023-01-01') SET CACHED IN 'pool_name'; +ALTER TABLE my_table SET CACHED IN 'pool_name' WITH REPLICATION = 3 ; +ALTER TABLE my_table PARTITION (date = '2023-01-01') SET CACHED IN 'pool_name' WITH REPLICATION = 2; +ALTER TABLE my_table SET UNCACHED; +ALTER TABLE my_table PARTITION (date = '2023-01-01') SET UNCACHED; + +-- example +alter table historical_data drop partition (year < 1995); +alter table historical_data drop partition (year < 1995, last_name like 'A%'); +alter table historical_data drop partition (year = 1996 and month between 1 and 6); +alter table fast_growing_data partition (year = 2016, month in (10,11,12)) set fileformat parquet; +alter table d1.mobile rename to mobile; +alter table d2.mobile rename to d3.mobile; +alter table p1 add partition (month=1, day=1); +alter table p1 add partition (month=1, day=2); +alter table p1 add partition (month=2, day=1); +alter table p1 add partition (month=2, day=2); +alter table p1 partition (month=1, day=1) set location '/usr/external_data/new_years_day'; +alter table t1 add partition (yy = 2016, mm = 2); +alter table t1 add partition (yy = 2016, mm = 3); +alter table t1 recover partitions; +alter table analysis_data set tblproperties('numRows'='1001000000', 'STATS_GENERATED_VIA_STATS_TASK'='true'); +alter table partitioned_data partition(year=2009, month=4) set tblproperties ('numRows'='30000', 'STATS_GENERATED_VIA_STATS_TASK'='true'); +alter table partitioned_data set tblproperties ('numRows'='1030000', 'STATS_GENERATED_VIA_STATS_TASK'='true'); +alter table t1 set column stats x ('numDVs'='2','numNulls'='0'); +alter table t1 set column stats s ('numdvs'='3','maxsize'='4'); +alter table optional_columns drop column a2; +alter table optional_columns drop column a1; +alter table p1 partition (month=2, day=2) set fileformat parquet; +alter table partition_t add partition (y=2000); +ALTER TABLE t1 ADD COLUMNS (y STRING ENCODING prefix_encoding); +ALTER TABLE t1 ADD COLUMNS (z INT DEFAULT 10); +ALTER TABLE t1 ADD COLUMNS (a STRING NOT NULL DEFAULT '', t TIMESTAMP COMPRESSION default_compression); +alter table kt alter column s set encoding prefix_encoding; +alter table kt alter x set block_size 2048; +alter table kt alter column t set compression zlib; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/alter_view.sql b/test/parser/impala/syntax/fixtures/alter_view.sql new file mode 100644 index 0000000..e81e3e7 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/alter_view.sql @@ -0,0 +1,43 @@ +-- ALTER VIEW [database_name.]view_name [(column_name [COMMENT 'column_comment'][, ...])] AS select_statement; +ALTER VIEW my_view +AS SELECT column_name1, column_name2, column_name3 FROM table_name; +ALTER VIEW my_view +(column_name1 COMMENT 'Column 1', column_name2, column_name3 COMMENT 'Column 3') +AS SELECT column_name1, column_name2, column_name3 FROM table_name; +ALTER VIEW db1.my_view +(column_name1 COMMENT 'Column 1', column_name2, column_name3 COMMENT 'Column 3') +AS SELECT column_name1, column_name2, column_name3 FROM table_name; +ALTER VIEW my_view +(col1 COMMENT 'Description for Column 1', col2, col3 COMMENT 'Description for Column 3') +AS SELECT col1, col2, col3 FROM my_table; + +-- ALTER VIEW [database_name.]view_name RENAME TO [database_name.]view_name; +ALTER VIEW db1.v1 RENAME TO db2.v2; +ALTER VIEW v1 RENAME TO db2.v2; +ALTER VIEW v1 RENAME TO v2; +ALTER VIEW db1.v1 RENAME TO v2; + +-- ALTER VIEW [database_name.]view_name SET OWNER USER user_name; +ALTER VIEW my_view SET OWNER USER 'name'; +ALTER VIEW db.my_view SET OWNER USER 'name'; + +-- ALTER VIEW [database_name.]view_name SET TBLPROPERTIES ('name' = 'value'[, 'name' = 'value' ...]); +ALTER VIEW v1 SET TBLPROPERTIES ('tblp1' = '1', 'tblp2' = '2', 'tblp3' = '3'); +ALTER VIEW db.v1 SET TBLPROPERTIES ('tblp1' = '1', 'tblp2' = '2', 'tblp3' = '3'); +ALTER VIEW db.v1 SET TBLPROPERTIES ('tblp1' = '1'); + + +-- ALTER VIEW [database_name.]view_name UNSET TBLPROPERTIES ('name'[, ...]); +ALTER VIEW v1 UNSET TBLPROPERTIES ('tblp1', 'tblp2'); +ALTER VIEW db.v1 UNSET TBLPROPERTIES ('tblp1'); +ALTER VIEW db.v1 UNSET TBLPROPERTIES ('tblp1', 'tblp2', 'tblp3'); + +-- example +ALTER VIEW v1 AS SELECT x, UPPER(s) s FROM t2; +ALTER VIEW v1 (c1, c2) AS SELECT x, UPPER(s) s FROM t2; +ALTER VIEW v7 (c1 COMMENT 'Comment for c1', c2) AS SELECT t1.c1, t1.c2 FROM t1; +ALTER VIEW db1.v1 RENAME TO db2.v2; +ALTER VIEW db1.v1 RENAME TO db1.v2; +ALTER VIEW db1.v1 RENAME TO db2.v1; +ALTER VIEW v1 SET TBLPROPERTIES ('tblp1' = '1', 'tblp2' = '2'); +ALTER VIEW v1 UNSET TBLPROPERTIES ('tblp1', 'tblp2'); diff --git a/test/parser/impala/syntax/fixtures/comment.sql b/test/parser/impala/syntax/fixtures/comment.sql new file mode 100644 index 0000000..131c990 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/comment.sql @@ -0,0 +1,15 @@ +-- COMMENT ON DATABASE db_name IS {'comment' | NULL} +COMMENT ON DATABASE my_database IS 'This is my database.'; +COMMENT ON DATABASE my_database IS NULL; + +-- COMMENT ON TABLE [db_name.]table_name IS {'comment' | NULL} +COMMENT ON TABLE my_database.my_table IS 'This is my table.'; +COMMENT ON TABLE my_database.my_table IS NULL; +COMMENT ON TABLE my_table IS 'This is my table.'; +COMMENT ON TABLE my_table IS NULL; + +-- COMMENT ON COLUMN [db_name.]table_name.column_name IS {'comment' | NULL} +COMMENT ON COLUMN my_database.my_table.age IS 'save for age.'; +COMMENT ON COLUMN my_database.my_table.age IS NULL; +COMMENT ON COLUMN my_table.age IS 'This is my table.'; +COMMENT ON COLUMN my_table.age IS NULL; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/compute_stats.sql b/test/parser/impala/syntax/fixtures/compute_stats.sql new file mode 100644 index 0000000..de1090a --- /dev/null +++ b/test/parser/impala/syntax/fixtures/compute_stats.sql @@ -0,0 +1,20 @@ +-- COMPUTE STATS [db_name.]table_name [ ( column_list ) ] [TABLESAMPLE SYSTEM(percentage) [REPEATABLE(seed)]] +COMPUTE STATS my_table; +COMPUTE STATS my_table (column1, column2); +COMPUTE STATS my_table TABLESAMPLE SYSTEM(20); +COMPUTE STATS my_table (column1, column2) TABLESAMPLE SYSTEM(2) REPEATABLE(456); +COMPUTE STATS my_table TABLESAMPLE SYSTEM(2) REPEATABLE(456); + + +-- COMPUTE INCREMENTAL STATS [db_name.]table_name [PARTITION (partition_spec)] +COMPUTE INCREMENTAL STATS my_table; +COMPUTE INCREMENTAL STATS my_table PARTITION (date='2023-11-14'); + +-- example +compute stats t1; +compute incremental stats int_partitions partition (x < 100); +compute incremental stats int_partitions partition (x in (100, 150, 200)); +compute incremental stats int_partitions partition (x between 100 and 175); +compute incremental stats int_partitions partition (x in (100, 150, 200) or x < 100); +compute incremental stats int_partitions partition (x != 150); +compute incremental stats item_partitioned; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/create_db.sql b/test/parser/impala/syntax/fixtures/create_db.sql new file mode 100644 index 0000000..e73f71b --- /dev/null +++ b/test/parser/impala/syntax/fixtures/create_db.sql @@ -0,0 +1,17 @@ +-- CREATE (DATABASE|SCHEMA) [IF NOT EXISTS] database_name[COMMENT 'database_comment'] [LOCATION hdfs_path]; +CREATE DATABASE my_db; +CREATE DATABASE IF NOT EXISTS my_db1; +CREATE DATABASE my_db COMMENT 'my first db'; +CREATE DATABASE my_db LOCATION '/path/to/partition'; +CREATE DATABASE my_db COMMENT 'my first db' LOCATION '/path/to/partition'; +CREATE DATABASE IF NOT EXISTS my_db COMMENT 'my first db' LOCATION '/path/to/partition'; +CREATE SCHEMA my_schema; +CREATE SCHEMA IF NOT EXISTS my_schema1; +CREATE SCHEMA my_schema COMMENT 'my first schema'; +CREATE SCHEMA my_schema LOCATION '/path/to/partition'; +CREATE SCHEMA my_schema COMMENT 'my first schema' LOCATION '/path/to/partition'; +CREATE SCHEMA IF NOT EXISTS my_schema COMMENT 'my first schema' LOCATION '/path/to/partition'; + + +-- example +create database first_db; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/create_function.sql b/test/parser/impala/syntax/fixtures/create_function.sql new file mode 100644 index 0000000..e74dc77 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/create_function.sql @@ -0,0 +1,83 @@ +/* CREATE FUNCTION [IF NOT EXISTS] [db_name.]function_name([arg_type[, arg_type...]) + RETURNS return_type + LOCATION 'hdfs_path_to_dot_so' + SYMBOL='symbol_name' */ +CREATE FUNCTION function_name(arg_type1, arg_type2) +RETURNS return_type +LOCATION 'hdfs_path_to_dot_so' +SYMBOL='symbol_name'; +CREATE FUNCTION db_name.function_name(arg_type1, arg_type2) +RETURNS return_type +LOCATION 'hdfs_path_to_dot_so' +SYMBOL='symbol_name'; +CREATE FUNCTION IF NOT EXISTS function_name(arg_type1, arg_type2) +RETURNS return_type +LOCATION 'hdfs_path_to_dot_so' +SYMBOL='symbol_name'; +CREATE FUNCTION IF NOT EXISTS db_name.function_name(arg_type1) +RETURNS return_type +LOCATION 'hdfs_path_to_dot_so' +SYMBOL='symbol_name'; +CREATE FUNCTION IF NOT EXISTS db_name.function_name(arg_type1, arg_type2, arg_type3) +RETURNS return_type +LOCATION 'hdfs_path_to_dot_so' +SYMBOL='symbol_name'; + +/* CREATE FUNCTION [IF NOT EXISTS] [db_name.]function_name + LOCATION 'hdfs_path_to_jar' + SYMBOL='class_name' */ +CREATE FUNCTION function_name +LOCATION 'hdfs_path_to_dot_so' +SYMBOL='symbol_name'; +CREATE FUNCTION db_name.function_name +LOCATION 'hdfs_path_to_dot_so' +SYMBOL='symbol_name'; +CREATE FUNCTION IF NOT EXISTS function_name +LOCATION 'hdfs_path_to_dot_so' +SYMBOL='symbol_name'; +CREATE FUNCTION IF NOT EXISTS db_name.function_name +LOCATION 'hdfs_path_to_dot_so' +SYMBOL='symbol_name'; + +/* CREATE [AGGREGATE] FUNCTION [IF NOT EXISTS] [db_name.]function_name([arg_type[, arg_type...]) + RETURNS return_type + [INTERMEDIATE type_spec] + LOCATION 'hdfs_path' + [INIT_FN='function] + UPDATE_FN='function + MERGE_FN='function + [PREPARE_FN='function] + [CLOSEFN='function] + [SERIALIZE_FN='function] + [FINALIZE_FN='function] */ +CREATE AGGREGATE FUNCTION function_name(arg_type1, arg_type2) +RETURNS return_type +LOCATION 'hdfs_path' +UPDATE_FN='update_function' +MERGE_FN='merge_function'; +CREATE AGGREGATE FUNCTION db_name.function_name(arg_type1, arg_type2) +RETURNS return_type +LOCATION 'hdfs_path' +UPDATE_FN='update_function' +MERGE_FN='merge_function'; +CREATE AGGREGATE FUNCTION IF NOT EXISTS function_name(arg_type1, arg_type2) +RETURNS return_type +LOCATION 'hdfs_path' +UPDATE_FN='update_function' +MERGE_FN='merge_function'; +CREATE AGGREGATE FUNCTION function_name(arg_type1, arg_type2) +RETURNS return_type +INTERMEDIATE intermediate_type +LOCATION 'hdfs_path' +INIT_FN ='init_function' +UPDATE_FN='update_function' +MERGE_FN='merge_function' +PREPARE_FN = 'prepare_fn' +CLOSEFN = 'closefn' +SERIALIZE_FN = 'serialize_function' +FINALIZE_FN = 'finalize_function'; + + +-- example +create function my_func location '/user/impala/udfs/udf-examples.jar' + symbol='org.apache.impala.TestUdf'; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/create_role.sql b/test/parser/impala/syntax/fixtures/create_role.sql new file mode 100644 index 0000000..9fd8647 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/create_role.sql @@ -0,0 +1,2 @@ +-- CREATE ROLE role_name +CREATE ROLE 'impala'; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/create_table.sql b/test/parser/impala/syntax/fixtures/create_table.sql new file mode 100644 index 0000000..bcd4fd2 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/create_table.sql @@ -0,0 +1,181 @@ +CREATE EXTERNAL TABLE external_parquet (c1 INT, c2 STRING, c3 TIMESTAMP) + STORED AS PARQUET LOCATION '/user/etl/destination'; + +create table census (name string, census_year int) partitioned by (year int); + +CREATE TABLE census_data (last_name STRING, first_name STRING, state STRING, address STRING) + SORT BY (last_name, state) + STORED AS PARQUET + TBLPROPERTIES ('transactional'='true', 'transactional_properties'='insert_only'); + +CREATE TABLE sorted_census_data + SORT BY (last_name, state) + STORED AS PARQUET + AS SELECT last_name, first_name, state, address + FROM unsorted_census_data; + +CREATE TABLE yy2 (s STRING, year INT); + +CREATE TABLE kudu_no_partition_by_clause + ( + id bigint PRIMARY KEY, s STRING, b BOOLEAN + ) + STORED AS KUDU; + +CREATE TABLE kudu_t1 (id BIGINT PRIMARY key, s STRING, b BOOLEAN) + PARTITION BY HASH (id) PARTITIONS 20 STORED AS KUDU; + +CREATE TABLE kudu_t2 (id BIGINT, s STRING, b BOOLEAN, PRIMARY KEY (id,s)) + PARTITION BY HASH (s) PARTITIONS 30 STORED AS KUDU; + +CREATE TABLE kudu_t3 (id BIGINT, year INT, s STRING, + b BOOLEAN, PRIMARY KEY (id,year)) + PARTITION BY HASH (id) PARTITIONS 20, + RANGE (year) (PARTITION 1980 <= VALUES < 1990, + PARTITION 1990 <= VALUES < 2000, + PARTITION VALUE = 2001, + PARTITION 2001 < VALUES < 2003) + STORED AS KUDU; + +CREATE EXTERNAL TABLE external_t1 STORED AS KUDU + TBLPROPERTIES ('kudu.table_name'='kudu_tbl_created_via_api'); + +CREATE EXTERNAL TABLE myextkudutbl ( + id int PRIMARY KEY, + name string) + PARTITION BY HASH PARTITIONS 8 + STORED AS KUDU + TBLPROPERTIES ('external.table.purge'='true'); + +CREATE TABLE ctas_t1 + PRIMARY KEY (id) PARTITION BY HASH (id) PARTITIONS 10 + STORED AS KUDU + AS SELECT id, s FROM kudu_t1; + +CREATE TABLE pk_multiple_columns +( + col1 BIGINT, + col2 STRING, + col3 BOOLEAN, + PRIMARY KEY (col1, col2) +) PARTITION BY HASH(col2) PARTITIONS 2 STORED AS KUDU; + +CREATE TABLE user.inline_pk_rewritten ( + id BIGINT NOT NULL ENCODING AUTO_ENCODING COMPRESSION DEFAULT_COMPRESSION, + s STRING NULL ENCODING AUTO_ENCODING COMPRESSION DEFAULT_COMPRESSION, + PRIMARY KEY (id) +) +PARTITION BY HASH (id) PARTITIONS 2 +STORED AS KUDU +TBLPROPERTIES ('kudu.master_addresses'='host.example.com'); + +CREATE TABLE default_vals +( + id BIGINT PRIMARY KEY, + name STRING NOT NULL DEFAULT 'unknown', + address STRING DEFAULT upper('no fixed address'), + age INT DEFAULT -1, + earthling BOOLEAN DEFAULT TRUE, + planet_of_origin STRING DEFAULT 'Earth', + optional_col STRING DEFAULT NULL +) PARTITION BY HASH(id) PARTITIONS 2 STORED AS KUDU; + +CREATE TABLE various_encodings +( + id BIGINT PRIMARY KEY, + c1 BIGINT ENCODING PLAIN_ENCODING, + c2 BIGINT ENCODING AUTO_ENCODING, + c3 TINYINT ENCODING BIT_SHUFFLE, + c4 DOUBLE ENCODING BIT_SHUFFLE, + c5 BOOLEAN ENCODING RLE, + c6 STRING ENCODING DICT_ENCODING, + c7 STRING ENCODING PREFIX_ENCODING +) PARTITION BY HASH(id) PARTITIONS 2 STORED AS KUDU; + + +CREATE TABLE blog_posts +( + user_id STRING ENCODING DICT_ENCODING, + post_id BIGINT ENCODING BIT_SHUFFLE, + subject STRING ENCODING PLAIN_ENCODING, + body STRING COMPRESSION LZ4, + spanish_translation STRING COMPRESSION SNAPPY, + esperanto_translation STRING COMPRESSION ZLIB, + PRIMARY KEY (user_id, post_id) +) PARTITION BY HASH(user_id, post_id) PARTITIONS 2 STORED AS KUDU; + + +CREATE TABLE various_encodings +( + id BIGINT PRIMARY KEY, + c1 BIGINT ENCODING PLAIN_ENCODING, + c2 BIGINT ENCODING AUTO_ENCODING, + c3 TINYINT ENCODING BIT_SHUFFLE, + c4 DOUBLE ENCODING BIT_SHUFFLE, + c5 BOOLEAN ENCODING RLE, + c6 STRING ENCODING DICT_ENCODING, + c7 STRING ENCODING PREFIX_ENCODING +) PARTITION BY HASH(id) PARTITIONS 2 STORED AS KUDU; + +create table million_rows_one_range (id string primary key, s string) + partition by hash(id) partitions 50, + range (partition 'a' <= values < '{') + stored as kudu; + +create table million_rows_two_ranges (id string primary key, s string) + partition by hash(id) partitions 50, + range (partition 'a' <= values < '{', partition 'A' <= values < '[', partition value = '00000') + stored as kudu; + +create table million_rows_three_ranges (id string primary key, s string) + partition by hash (school) partitions 10, + range (letter_grade) (partition value = 'A', partition value = 'B', + partition value = 'C', partition value = 'D', partition value = 'F') + stored as kudu; + +create table hash_t5 (x bigint, y bigint, s string, primary key (x,y)) + partition by hash (x) partitions 10, hash (y) partitions 20, hash (y) partitions 20 + stored as kudu; + +create table range_t1 (x bigint, s string, s2 string, primary key (x, s)) + partition by range (x) + ( + partition 0 <= values <= 49, partition 50 <= values <= 100, + partition value < 0, partition 100 < values <= 500, + partition values < 0, partition 100 < values + ) + stored as kudu; + +create table combined_t1 (x bigint, s string, s2 string, primary key (x, s)) + partition by hash (x) partitions 10, range (x) + ( + partition 0 <= values <= 49, partition 50 <= values <= 100 + ) + stored as kudu; + +CREATE TABLE t5 AS SELECT upper(y) AS s, x+1 AS a, 'Entirely new column' AS n FROM t1; + +CREATE TABLE parquet_version_of_t1 STORED AS PARQUET AS SELECT * FROM t1; + +create table partitions_yes partitioned by (year, month) + as select s, year, month from partitions_no; + +CREATE TABLE my_first_table (id BIGINT, name STRING, PRIMARY KEY (id)) PARTITION BY HASH PARTITIONS 16 STORED AS KUDU TBLPROPERTIES ('kudu.num_tablet_replicas' = '1'); + +CREATE TABLE parquet_table (id INT) STORED AS PARQUET; + +CREATE TABLE games3 (id BIGINT, play ARRAY < MAP < STRING, BIGINT > >) STORED AS PARQUET; + +CREATE TABLE games3 (id BIGINT, play ARRAY < MAP < STRING, BIGINT > >) STORED AS PARQUET; + +create table unsorted (x bigint); + +CREATE TABLE pk(col1 INT, col2 STRING, PRIMARY KEY(col1, col2)); + +CREATE TABLE fk(id INT, col1 INT, col2 STRING, PRIMARY KEY(id), + FOREIGN KEY(col1, col2) REFERENCES pk(col1, col2)); + +CREATE TABLE pk(id INT, PRIMARY KEY(id) DISABLE, NOVALIDATE, RELY); + +CREATE TABLE fk(id INT, col1 INT, col2 STRING, PRIMARY KEY(id), + FOREIGN KEY(col1, col2) REFERENCES pk(col1, col2)); \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/create_view.sql b/test/parser/impala/syntax/fixtures/create_view.sql new file mode 100644 index 0000000..88da39b --- /dev/null +++ b/test/parser/impala/syntax/fixtures/create_view.sql @@ -0,0 +1,22 @@ +/* CREATE VIEW [IF NOT EXISTS] view_name + [(column_name [COMMENT 'column_comment'][, ...])] + [COMMENT 'view_comment'] + [TBLPROPERTIES ('name' = 'value'[, ...])] + AS select_statement */ +CREATE VIEW my_view AS SELECT * FROM my_table; +CREATE VIEW IF NOT EXISTS my_view AS SELECT * FROM my_table; +CREATE VIEW IF NOT EXISTS my_view (age COMMENT 'this is number col') AS SELECT * FROM my_table; +CREATE VIEW IF NOT EXISTS my_view (age COMMENT 'this is number col') COMMENT 'this is test view' AS SELECT * FROM my_table; +CREATE VIEW my_view (age COMMENT 'this is number col') COMMENT 'this is test view' TBLPROPERTIES ('tblp1' = '1', 'aaa' = '2') AS SELECT * FROM my_table; +CREATE VIEW my_view COMMENT 'this is test view' TBLPROPERTIES ('tblp1' = '1', 'aaa' = '2') AS SELECT * FROM my_table; +CREATE VIEW my_view (age COMMENT 'this is number col', age1 COMMENT 'this is number col') TBLPROPERTIES ('tblp1' = '1') AS SELECT * FROM my_table; + +-- example +CREATE VIEW v1 AS SELECT * FROM t1; +CREATE VIEW v2 AS SELECT c1, c3, c7 FROM t1; +CREATE VIEW v3 AS SELECT DISTINCT c1, c3, c7 FROM t1 WHERE c1 IS NOT NULL AND c5 > 0; +CREATE VIEW v4 AS SELECT c4 AS last_name, c6 AS address, c2 AS birth_date FROM t1; +CREATE VIEW v5 AS SELECT c1, CAST(c3 AS STRING) c3, CONCAT(c4,c5) c5, TRIM(c6) c6, "Constant" c8 FROM t1; +CREATE VIEW v6 AS SELECT t1.c1, t2.c2 FROM t1 JOIN t2 ON t1.id = t2.id; +CREATE VIEW v7 (c1 COMMENT 'Comment for c1', c2) COMMENT 'Comment for v7' AS SELECT t1.c1, t1.c2 FROM t1; +CREATE VIEW v7 (c1 , c2) TBLPROPERTIES ('tblp1' = '1') AS SELECT t1.c1, t1.c2 FROM t1; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/delete.sql b/test/parser/impala/syntax/fixtures/delete.sql new file mode 100644 index 0000000..74ad1e8 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/delete.sql @@ -0,0 +1,42 @@ +-- DELETE [FROM] [database_name.]table_name [ WHERE where_conditions ] +DELETE FROM my_database.my_table; + +DELETE my_database.my_table; + +DELETE my_table; + +DELETE FROM my_table; + +DELETE FROM my_table WHERE col1 LIKE 'prefix%'; + +DELETE FROM my_table WHERE col1 IN (SELECT col2 FROM other_table WHERE col3 = 'value1'); + +-- example +DELETE FROM my_table; + +DELETE my_table; + +DELETE FROM my_table WHERE c1 = 100; + +DELETE FROM my_table WHERE + (c1 > c2 OR c3 IN ('hello','world')) AND c4 IS NOT NULL; + +DELETE FROM t1 WHERE + (c1 IN (1,2,3) AND c2 > c3) OR c4 IS NOT NULL; + +DELETE FROM time_series WHERE + year = 2016 AND month IN (11,12) AND day > 15; + +DELETE FROM t1 WHERE + c5 IN (SELECT DISTINCT other_col FROM other_my_table); + +DELETE FROM my_table WHERE 1 = 0; + +DELETE t1 FROM t1 JOIN t2 ON t1.x = t2.x; + +DELETE t1 FROM t1 JOIN t2 ON t1.x = t2.x + WHERE t1.y = FALSE and t2.z > 100; + +DELETE t1 FROM my_table t1 JOIN other_table t2 ON t1.x = t2.x; + +DELETE t2 FROM non_kudu_non_ice_table t1 JOIN kudu_or_ice_table t2 ON t1.x = t2.x; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/describe.sql b/test/parser/impala/syntax/fixtures/describe.sql new file mode 100644 index 0000000..4febd1d --- /dev/null +++ b/test/parser/impala/syntax/fixtures/describe.sql @@ -0,0 +1,17 @@ +-- DESCRIBE [DATABASE] [FORMATTED|EXTENDED] object_name +DESCRIBE my_table; +DESCRIBE DATABASE my_table; +DESCRIBE DATABASE FORMATTED my_table; +DESCRIBE DATABASE EXTENDED my_table; +DESCRIBE FORMATTED my_table; +DESCRIBE EXTENDED my_table; +DESCRIBE FORMATTED my_table; +DESCRIBE EXTENDED my_db_name.my_table.my_col; +DESCRIBE FORMATTED my_db; + +-- example +describe my_table; +describe my_database.my_table; +describe formatted my_table; +describe customer.c_orders.item; +describe customer.c_orders.item.o_lineitems; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/drop_db.sql b/test/parser/impala/syntax/fixtures/drop_db.sql new file mode 100644 index 0000000..e81babb --- /dev/null +++ b/test/parser/impala/syntax/fixtures/drop_db.sql @@ -0,0 +1,13 @@ +-- DROP (DATABASE|SCHEMA) [IF EXISTS] database_name [RESTRICT | CASCADE]; +DROP DATABASE my_database; +DROP DATABASE IF EXISTS my_database; +DROP DATABASE my_database RESTRICT; +DROP DATABASE IF EXISTS my_database CASCADE; +DROP SCHEMA my_database; +DROP SCHEMA IF EXISTS my_database; +DROP SCHEMA my_database RESTRICT; +DROP SCHEMA IF EXISTS my_database CASCADE; + +-- example +drop database temp; +drop database temp cascade; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/drop_function.sql b/test/parser/impala/syntax/fixtures/drop_function.sql new file mode 100644 index 0000000..38bb453 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/drop_function.sql @@ -0,0 +1,16 @@ +-- DROP [AGGREGATE] FUNCTION [IF EXISTS] [db_name.]function_name(type[, type...]) +DROP FUNCTION my_function(integer, text); +DROP FUNCTION IF EXISTS my_function(integer, boolean); +DROP FUNCTION my_database.my_function(integer); +DROP AGGREGATE FUNCTION my_function(integer, text); +DROP AGGREGATE FUNCTION IF EXISTS my_function(integer, text, binary); +DROP AGGREGATE FUNCTION my_database.my_function(integer); + +-- DROP FUNCTION [IF EXISTS] [db_name.]function_name +DROP FUNCTION my_db.my_func; +DROP FUNCTION IF EXISTS my_func; +DROP FUNCTION my_func; +DROP FUNCTION IF EXISTS my_db.my_func; + +-- example +drop function my_func; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/drop_role.sql b/test/parser/impala/syntax/fixtures/drop_role.sql new file mode 100644 index 0000000..7870516 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/drop_role.sql @@ -0,0 +1,2 @@ +-- DROP ROLE role_name +DROP ROLE 'impala'; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/drop_stats.sql b/test/parser/impala/syntax/fixtures/drop_stats.sql new file mode 100644 index 0000000..1bcf88a --- /dev/null +++ b/test/parser/impala/syntax/fixtures/drop_stats.sql @@ -0,0 +1,12 @@ +-- DROP STATS [database_name.]table_name +DROP STATS my_table; +DROP STATS my_db.my_table; + +-- DROP INCREMENTAL STATS [database_name.]table_name PARTITION (partition_spec) +DROP INCREMENTAL STATS my_table PARTITION (date = "1111-11-11"); +DROP INCREMENTAL STATS my_db.my_table PARTITION (year < 1995 and last_name like 'A%'); + +-- example +drop incremental stats item_partitioned partition (i_category='Sports'); +drop incremental stats item_partitioned partition (i_category='Electronics'); +drop stats item_partitioned; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/drop_table.sql b/test/parser/impala/syntax/fixtures/drop_table.sql new file mode 100644 index 0000000..f30fb98 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/drop_table.sql @@ -0,0 +1,10 @@ +-- DROP TABLE [IF EXISTS] [db_name.]table_name [PURGE] +DROP TABLE my_table; +DROP TABLE my_db.my_table; +DROP TABLE IF EXISTS my_table; +DROP TABLE IF EXISTS my_db.my_table; +DROP TABLE IF EXISTS my_db.my_table PURGE; + +-- example +drop table unimportant; +drop table my_db.trivial; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/drop_view.sql b/test/parser/impala/syntax/fixtures/drop_view.sql new file mode 100644 index 0000000..9f3aab7 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/drop_view.sql @@ -0,0 +1,9 @@ +-- DROP VIEW [IF EXISTS] [db_name.]view_name +DROP VIEW my_view; +DROP VIEW my_db.my_view; +DROP VIEW IF EXISTS my_view; +DROP VIEW IF EXISTS my_db.my_view; + +-- example +drop view unimportant; +drop view my_db.trivial; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/explain.sql b/test/parser/impala/syntax/fixtures/explain.sql new file mode 100644 index 0000000..53aede6 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/explain.sql @@ -0,0 +1,11 @@ +-- EXPLAIN { select_query | ctas_stmt | insert_stmt } +EXPLAIN SELECT * FROM my_table; +EXPLAIN CREATE TABLE t1 (x INT, y STRING); +EXPLAIN INSERT INTO t1 VALUES (1, 'one'), (2, 'two'), (3, 'three'); + +-- example +EXPLAIN SELECT COUNT(*) FROM customer_address; +EXPLAIN SELECT * FROM functional_kudu.alltypestiny WHERE bigint_col < 1000 / 100; +EXPLAIN SELECT x,y from kudu_table WHERE + x = 1 AND y NOT IN (2,3) AND z = 1 + AND a IS NOT NULL AND b > 0 AND length(s) > 5; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/grant.sql b/test/parser/impala/syntax/fixtures/grant.sql new file mode 100644 index 0000000..dde813c --- /dev/null +++ b/test/parser/impala/syntax/fixtures/grant.sql @@ -0,0 +1,35 @@ +-- GRANT ROLE role_name TO GROUP group_name +GRANT ROLE role_name TO GROUP group_name + +-- GRANT privilege ON object_type object_name TO USER user_name +GRANT ALL ON SERVER my_server TO USER 'impala'; +GRANT ALTER ON DATABASE my_database TO USER 'impala'; +GRANT CREATE ON TABLE my_table TO USER 'impala'; +GRANT DROP ON URI my_uri TO USER 'impala'; +GRANT INSERT ON URI my_uri TO USER 'impala'; +GRANT REFRESH ON TABLE my_table TO USER 'impala'; +GRANT SELECT ON TABLE my_table TO USER 'impala'; +GRANT SELECT(column_name) ON TABLE my_table TO USER 'impala'; + +-- GRANT privilege ON object_type object_name TO GROUP group_name +GRANT ALL ON SERVER my_server TO GROUP 'impala_group'; +GRANT ALTER ON DATABASE my_database TO GROUP 'impala_group'; +GRANT CREATE ON TABLE my_table TO GROUP 'impala_group'; +GRANT DROP ON URI my_uri TO GROUP 'impala_group'; +GRANT INSERT ON URI my_uri TO GROUP 'impala_group'; +GRANT REFRESH ON TABLE my_table TO GROUP 'impala_group'; +GRANT SELECT ON TABLE my_table TO GROUP 'impala_group'; +GRANT SELECT(column_name) ON TABLE my_table TO GROUP 'impala_group'; + +-- GRANT privilege ON object_type object_name TO ROLE group_name +GRANT ALL ON SERVER my_server TO ROLE 'impala_role'; +GRANT ALTER ON DATABASE my_database TO ROLE 'impala_role'; +GRANT CREATE ON TABLE my_table TO ROLE 'impala_role'; +GRANT DROP ON URI my_uri TO ROLE 'impala_role'; +GRANT INSERT ON URI my_uri TO ROLE 'impala_role'; +GRANT REFRESH ON TABLE my_table TO ROLE 'impala_role'; +GRANT SELECT ON TABLE my_table TO ROLE 'impala_role'; +GRANT SELECT(column_name) ON TABLE my_table TO ROLE 'impala_role'; + +-- example +GRANT ALL ON SERVER TO ROLE foo_role; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/insert.sql b/test/parser/impala/syntax/fixtures/insert.sql new file mode 100644 index 0000000..57ecbf1 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/insert.sql @@ -0,0 +1,199 @@ +/* [with_clause] +INSERT [hint_clause] { INTO | OVERWRITE } [TABLE] table_name +[(column_list)] +[ PARTITION (partition_clause)] +{ +[hint_clause] select_statement +| VALUES (value [, value ...]) [, (value [, value ...]) ...] +} */ +-- INSERT [hint_clause] { INTO | OVERWRITE } table_name [hint_clause] select_statement +INSERT INTO my_table +SELECT + * +from + my_table1; + +INSERT OVERWRITE my_table +SELECT + * +from + my_table1; + +INSERT +INTO target_table +SELECT + val1, + val2, + val3 +FROM + dual +WHERE + NOT EXISTS ( + SELECT + 1 + FROM + target_table + WHERE + col1 = val1 + ); + +-- INSERT { INTO | OVERWRITE } table_name [(column_list)] [ PARTITION (partition_clause)] select_statement +INSERT INTO + target_table (col1, col2, col3) PARTITION (year = 2016, month IN (10, 11, 12)) +SELECT + * +FROM + dual; + +INSERT OVERWRITE target_table (col1, col2, col3) PARTITION (year BETWEEN 2016 AND 2030, month IN (10, 11, 12)) +SELECT + * +FROM + dual; + +-- INSERT [hint_clause] { INTO | OVERWRITE } table_name [hint_clause] VALUES (value [, value ...]) [, (value [, value ...]) ...] +INSERT +OVERWRITE target_table (col1, col2, col3) PARTITION (year BETWEEN 2016 AND 2030, month IN (10, 11, 12)) +VALUES + (col1, 'a'), + (col2, 'b'), + (col3, 'xyzzy'); + +WITH + cte AS ( + SELECT + col1, + col2 + FROM + source_table + WHERE + condition + ) +INSERT INTO + target_table (col1, col2) +SELECT + col1, + col2 +FROM + cte; + +-- example +insert into + table text_table +select + * +from + default.tab1; + +insert overwrite table parquet_table +select + * +from + default.tab1 +limit + 3; + +insert into + val_test_1 +values + (100, 99.9 / 10, 'abc', true, now ()); + +insert overwrite val_test_2 +values + (1, 'a'), + (2, 'b'), + (-1, 'xyzzy'); + +insert into + t2 +select + * +from + t1; + +insert into + t2 +select + c1, + c2 +from + t1; + +insert into + t2 (c1) +select + c1 +from + t1; + +insert into + t2 (c2, c1) +select + c1, + c2 +from + t1; + +insert into + t2 (y) +select + c1 +from + t1; + +INSERT INTO + t1 PARTITION (x = 10, y = 'a') +SELECT + c1 +FROM + some_other_table; + +INSERT INTO + t1 PARTITION (x, y) +VALUES + (1, 2, ' c '); + +INSERT INTO + t1 (w) PARTITION (x, y) +VALUES + (1, 2, ' c '); + +INSERT INTO + t1 PARTITION (x, y = 'c') +VALUES + (1, 2); + +INSERT INTO + t1 PARTITION (x = 20, y) +SELECT + * +FROM + source; + +with + t1 as ( + select + 1 + ), + t2 as ( + select + 2 + ) +insert into + tab +select + * +from + t1 +union all +select + * +from + t2; + +insert into + sample_demo_partitions partition (n = 3) +select + * +from + sample_demo; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/invalidate_metadata.sql b/test/parser/impala/syntax/fixtures/invalidate_metadata.sql new file mode 100644 index 0000000..e5311c7 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/invalidate_metadata.sql @@ -0,0 +1,6 @@ +-- INVALIDATE METADATA [[db_name.]table_name] +INVALIDATE METADATA new_table_from_hive; +INVALIDATE METADATA new_db_from_hive.new_table_from_hive; + +-- example +INVALIDATE METADATA new_db_from_hive.new_table_from_hive; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/load_data.sql b/test/parser/impala/syntax/fixtures/load_data.sql new file mode 100644 index 0000000..08f4007 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/load_data.sql @@ -0,0 +1,9 @@ +/* LOAD DATA INPATH 'hdfs_file_or_directory_path' [OVERWRITE] INTO TABLE tablename + [PARTITION (partcol1=val1, partcol2=val2 ...)] */ +LOAD DATA INPATH 'hdfs_file_or_directory_path' INTO TABLE my_table; +LOAD DATA INPATH 'hdfs_file_or_directory_path' OVERWRITE INTO TABLE my_table; +LOAD DATA INPATH 'hdfs_file_or_directory_path' INTO TABLE my_table PARTITION (country = 'USA', age = 18); +LOAD DATA INPATH 'hdfs_file_or_directory_path' OVERWRITE INTO TABLE my_table PARTITION (country = 'USA', age = 18); + +-- example +load data inpath '/user/doc_demo/thousand_strings.txt' into table t1; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/refresh.sql b/test/parser/impala/syntax/fixtures/refresh.sql new file mode 100644 index 0000000..e78ec15 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/refresh.sql @@ -0,0 +1,9 @@ +-- REFRESH [db_name.]table_name [PARTITION (key_col1=val1 [, key_col2=val2...])] +REFRESH my_table; +REFRESH my_db.my_table; +REFRESH my_db.my_table PARTITION (age BETWEEN 100 AND 200, key_col2=val2, date = "1110-10-10"); +REFRESH table_name PARTITION (key_col1=val1, key_col2=val2, date = "1110-10-10"); + +-- example +refresh p2 partition (y=0, z=3); +refresh p2 partition (y=0, z=-1); diff --git a/test/parser/impala/syntax/fixtures/refresh_authorization.sql b/test/parser/impala/syntax/fixtures/refresh_authorization.sql new file mode 100644 index 0000000..62c9372 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/refresh_authorization.sql @@ -0,0 +1,2 @@ +-- REFRESH AUTHORIZATION +REFRESH AUTHORIZATION; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/refresh_function.sql b/test/parser/impala/syntax/fixtures/refresh_function.sql new file mode 100644 index 0000000..a29dc03 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/refresh_function.sql @@ -0,0 +1,2 @@ +--REFRESH FUNCTIONS db_name +REFRESH FUNCTIONS my_db; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/revoke.sql b/test/parser/impala/syntax/fixtures/revoke.sql new file mode 100644 index 0000000..cdba535 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/revoke.sql @@ -0,0 +1,32 @@ +-- REVOKE ROLE role_name FROM GROUP group_name +REVOKE ROLE my_role FROM GROUP my_group; + +-- REVOKE privilege ON object_type object_name FROM USER user_name +REVOKE ALL ON SERVER my_server FROM USER 'impala'; +REVOKE ALTER ON DATABASE my_database FROM USER 'impala'; +REVOKE CREATE ON TABLE my_table FROM USER 'impala'; +REVOKE DROP ON URI my_uri FROM USER 'impala'; +REVOKE INSERT ON URI my_uri FROM USER 'impala'; +REVOKE REFRESH ON TABLE my_table FROM USER 'impala'; +REVOKE SELECT ON TABLE my_table FROM USER 'impala'; +REVOKE SELECT(column_name) ON TABLE my_table FROM USER 'impala'; + +-- REVOKE privilege ON object_type object_name FROM GROUP group_name +REVOKE ALL ON SERVER my_server FROM GROUP 'impala_group'; +REVOKE ALTER ON DATABASE my_database FROM GROUP 'impala_group'; +REVOKE CREATE ON TABLE my_table FROM GROUP 'impala_group'; +REVOKE DROP ON URI my_uri FROM GROUP 'impala_group'; +REVOKE INSERT ON URI my_uri FROM GROUP 'impala_group'; +REVOKE REFRESH ON TABLE my_table FROM GROUP 'impala_group'; +REVOKE SELECT ON TABLE my_table FROM GROUP 'impala'; +REVOKE SELECT(column_name) ON TABLE my_table FROM GROUP 'impala_group'; + +-- REVOKE [GRANT OPTION FOR] privilege ON object_type object_name FROM [ROLE] role_name +REVOKE ALL ON SERVER my_server FROM 'impala_role'; +REVOKE GRANT OPTION FOR ALL ON SERVER my_server FROM ROLE 'impala_role'; +REVOKE SELECT ON DATABASE my_table FROM ROLE 'impala_role'; +REVOKE GRANT OPTION FOR SELECT(column_name) ON TABLE my_table FROM 'impala_role'; + +-- example +REVOKE GRANT OPTION FOR ALL ON SERVER FROM ROLE foo_role; +REVOKE ALL ON SERVER FROM ROLE foo_role; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/select.sql b/test/parser/impala/syntax/fixtures/select.sql new file mode 100644 index 0000000..7e31308 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/select.sql @@ -0,0 +1,191 @@ +-- example +-- JOINS +SELECT * from a; +SELECT t1.c1, t2.c2 FROM t1 JOIN t2 + ON t1.id = t2.id and t1.type_flag = t2.type_flag + WHERE t1.c1 > 100; + +SELECT t1.c1, t2.c2 FROM t1 JOIN t2 + USING (id, type_flag) + WHERE t1.c1 > 100; + +SELECT t1.c1, t2.c2 FROM t1, t2 + WHERE + t1.id = t2.id AND t1.type_flag = t2.type_flag + AND t1.c1 > 100; + +SELECT lhs.id, rhs.parent, lhs.c1, rhs.c2 FROM tree_data lhs, tree_data rhs WHERE lhs.id = rhs.parent; + +SELECT t1.id, c1, c2 FROM t1, t2 WHERE t1.id = t2.id; + +SELECT t1.id, c1, c2 FROM t1 JOIN t2 ON t1.id = t2.id; + +SELECT t1.id, c1, c2 FROM t1 INNER JOIN t2 ON t1.id = t2.id; + +SELECT * FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.id; + +SELECT * FROM t1 RIGHT OUTER JOIN t2 ON t1.id = t2.id; + +SELECT * FROM t1 FULL OUTER JOIN t2 ON t1.id = t2.id; + +SELECT * FROM t1 CROSS JOIN t2 WHERE t1.total > t2.maximum_price; + +SELECT * FROM t1 LEFT OUTER JOIN t2 ON t1.int_col < t2.int_col; + +SELECT t1.c1, t1.c2, t1.c2 FROM t1 LEFT SEMI JOIN t2 ON t1.id = t2.id; + +select t1.c1 as first_id, t2.c2 as second_id from + t1 join t2 on first_id = second_id; + +select fact.custno, dimension.custno from + customer_data as fact join customer_address as dimension + using (custno); + +-- ORDER BY +SELECT id FROM games ORDER BY score DESC; + +SELECT id, item FROM games, games.score + WHERE item > 1000000 +ORDER BY id, item desc; + +SELECT id, info.key1 AS k, info.value1 AS v from games3, games3.play AS plays, games3.item AS info + WHERE info.KEY1 = 'score' AND info.VALUE1 > 1000000 +ORDER BY id, info.value1 desc; + +SELECT user_id AS "Top 10 Visitors", SUM(page_views) FROM web_stats + GROUP BY page_views, user_id + ORDER BY SUM(page_views) DESC LIMIT 10; + +SELECT page_title AS "Page 3 of search results", page_url FROM search_content + WHERE LOWER(page_title) LIKE '%game%' + ORDER BY page_title LIMIT 10 OFFSET 20; + +select x from numbers order by x desc nulls last; + +-- GROUP BY +select + ss_item_sk as Item, + count(ss_item_sk) as Times_Purchased, + sum(ss_quantity) as Total_Quantity_Purchased +from store_sales + group by ss_item_sk + order by sum(ss_quantity) desc + limit 5; + +select + ss_item_sk as Item, + count(ss_item_sk) as Times_Purchased, + sum(ss_quantity) as Total_Quantity_Purchased +from store_sales + group by ss_item_sk + having times_purchased >= 100 + order by sum(ss_quantity) + limit 5; + +select ss_wholesale_cost, avg(ss_quantity * ss_sales_price) as avg_revenue_per_sale + from sales + group by ss_wholesale_cost + order by avg_revenue_per_sale desc + limit 5; + +select x as "Top 3" from numbers order by x desc limit 3; + +SELECT X FROM T1 LIMIT LENGTH('HELLO WORLD'); +SELECT x FROM t1 LIMIT cast(truncate(9.9) AS INT); + +-- UNION +select * from (select x from few_ints union all select x from few_ints) as t1 order by x; + +-- Subqueries +SELECT employee_name, employee_id FROM employees one WHERE + salary > (SELECT avg(salary) FROM employees two WHERE one.dept_id = two.dept_id); + +SELECT avg(t1.x), max(t2.y) FROM + (SELECT id, cast(a AS DECIMAL(10,5)) AS x FROM raw_data WHERE a BETWEEN 0 AND 100) AS t1 + JOIN + (SELECT id, length(s) AS y FROM raw_data WHERE s LIKE 'A%') AS t2 + USING (id); + +SELECT count(x) FROM t1 WHERE EXISTS(SELECT 1 FROM t2 WHERE t1.x = t2.y * 10); + +SELECT x FROM t1 WHERE x IN (SELECT y FROM t2 WHERE state = 'CA'); + +SELECT x FROM t1 WHERE y = (SELECT max(z) FROM t2); + +SELECT x FROM t1 WHERE y > (SELECT count(z) FROM t2); + +SELECT * FROM t1 one WHERE id IN (SELECT parent FROM t1 two WHERE t1.parent = t2.id); + +-- TABLESAMPLE +select distinct x from sample_demo tablesample system(50); + +select distinct x from sample_demo + tablesample system(50) repeatable (12345); + +select count(*) from sample_demo_partitions + tablesample system(50) where n = 1; + +-- WITH +with t1 as (select 1), t2 as (select 2) insert into tab select * from t1 union all select * from t2; + +-- DISTINCT +SELECT COUNT(DISTINCT c_salutation, c_last_name) FROM customer; + +SELECT DISTINCT c_salutation, c_last_name FROM customer; + +-- OTHERS +select + r_name, + count(r_nations.item.n_nationkey) as count, + sum(r_nations.item.n_nationkey) as sum, + avg(r_nations.item.n_nationkey) as avg, + min(r_nations.item.n_name) as minimum, + max(r_nations.item.n_name) as maximum, + ndv(r_nations.item.n_nationkey) as distinct_vals +from + region, region.r_nations as r_nations +group by r_name +order by r_name; + +select "contains an even number" as assertion from t3 where exists (select z from t3 where z % 2 = 0) limit 1; + +select null is distinct from null, null != null; + +select + 'x' is distinct from 'x ' as string_with_trailing_spaces, + cast('x' as char(5)) is distinct from cast('x ' as char(5)) as char_with_trailing_spaces; + +select c_first_name, c_last_name from customer where c_first_name regexp '^J.*'; + +SELECT + t1.transaction_id as transaction_id1, + t1.customer_id, + t1.transaction_date, + t1.transaction_amount, + t2.transaction_id as subsequent_transaction_id +FROM + transactions t1 + LEFT JOIN ( + SELECT + transaction_id, + customer_id, + transaction_date, + transaction_amount, + LEAD (transaction_id) OVER ( + PARTITION BY + customer_id + ORDER BY + transaction_date + ) AS transaction_id + FROM + transactions + ) t2 ON t1.transaction_id = t2.transaction_id + AND t1.customer_id = t2.customer_id + AND t1.transaction_date = t2.transaction_date + AND t1.transaction_amount = t2.transaction_amount; + +select appx_median(x) from million_numbers; + +select count(x) as higher from million_numbers where x > (select appx_median(x) from million_numbers); + +select avg(length(s)) from t1; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/set.sql b/test/parser/impala/syntax/fixtures/set.sql new file mode 100644 index 0000000..d52eacb --- /dev/null +++ b/test/parser/impala/syntax/fixtures/set.sql @@ -0,0 +1,7 @@ +-- SET +SET; +-- SET ALL +SET ALL; +-- SET query_option=option_value +set compression_codec=gzip; +set mt_dop = 0; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/show.sql b/test/parser/impala/syntax/fixtures/show.sql new file mode 100644 index 0000000..f1eb645 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/show.sql @@ -0,0 +1,167 @@ +-- SHOW DATABASES [[LIKE] 'pattern'] +SHOW DATABASES; + +SHOW DATABASES 'xxx'; + +SHOW DATABASES LIKE 'xxx'; + +-- SHOW SCHEMAS [[LIKE] 'pattern'] +SHOW SCHEMAS; + +SHOW SCHEMAS 'xxx'; + +SHOW SCHEMAS LIKE 'xxx'; + +-- SHOW TABLES [IN database_name] [[LIKE] 'pattern'] +SHOW TABLES; + +SHOW TABLES 'xxx'; + +SHOW TABLES LIKE 'xxx'; + +SHOW TABLES IN my_db; + +SHOW TABLES IN my_db 'xxx'; + +SHOW TABLES IN my_db LIKE 'xxx'; + +-- SHOW [AGGREGATE | ANALYTIC] FUNCTIONS [IN database_name] [[LIKE] 'pattern'] +SHOW FUNCTIONS; + +SHOW FUNCTIONS 'xxx'; + +SHOW FUNCTIONS LIKE 'xxx'; + +SHOW FUNCTIONS IN my_db; + +SHOW FUNCTIONS IN my_db 'xxx'; + +SHOW FUNCTIONS IN my_db LIKE 'xxx'; + +SHOW ANALYTIC FUNCTIONS IN my_db LIKE 'xxx'; + +SHOW AGGREGATE FUNCTIONS IN my_db LIKE 'xxx'; + +-- SHOW CREATE TABLE [database_name].table_name +SHOW CREATE TABLE my_table; + +SHOW CREATE TABLE my_db.my_table; + +-- SHOW CREATE VIEW [database_name].view_name +SHOW CREATE VIEW my_table; + +SHOW CREATE VIEW my_db.my_table; + +-- SHOW TABLE STATS [database_name.]table_name +SHOW TABLE STATS my_table; + +SHOW TABLE STATS my_db.my_table; + +-- SHOW COLUMN STATS [database_name.]table_name +SHOW COLUMN STATS my_table; + +SHOW COLUMN STATS my_db.my_table; + +-- SHOW PARTITIONS [database_name.]table_name +SHOW PARTITIONS my_table; + +SHOW PARTITIONS my_db.my_table; + +-- SHOW [RANGE] PARTITIONS [database_name.]table_name +SHOW RANGE PARTITIONS my_table; + +SHOW RANGE PARTITIONS my_db.my_table; + +-- SHOW FILES IN [database_name.]table_name [PARTITION (key_col_expression [, key_col_expression]] +SHOW FILES IN my_table; + +SHOW FILES IN my_db.my_table; + +SHOW FILES IN my_db.my_table PARTITION ( + "date" = "1110-11-11", + age BETWEEN 100 + AND 200 +); + +SHOW ROLES; + +SHOW CURRENT ROLES; + +SHOW ROLE GRANT GROUP group_name; + +SHOW GRANT USER user_name; + +SHOW GRANT USER user_name ON SERVER; + +SHOW GRANT USER user_name ON DATABASE database_name; + +SHOW GRANT USER user_name ON TABLE database_name.table_name; + +SHOW GRANT USER user_name ON URI my_uri; + +SHOW GRANT USER user_name ON COLUMN database_name.table_name.column_name; + +SHOW GRANT ROLE role_name; + +SHOW GRANT ROLE role_name ON SERVER; + +SHOW GRANT ROLE role_name ON DATABASE database_name; + +SHOW GRANT ROLE role_name ON TABLE database_name.table_name; + +SHOW GRANT ROLE role_name ON URI my_uri; + +SHOW GRANT ROLE role_name ON COLUMN database_name.table_name.column_name; + +SHOW GRANT GROUP group_name ON SERVER; + +SHOW GRANT GROUP group_name ON DATABASE database_name; + +SHOW GRANT GROUP group_name ON TABLE database_name.table_name; + +SHOW GRANT GROUP group_name ON URI my_uri; + +SHOW GRANT GROUP group_name ON COLUMN database_name.table_name.column_name; + +-- example +SHOW DATABASES 'a*'; + +SHOW DATABASES LIKE 'a*'; + +SHOW TABLES IN some_db LIKE '*fact*'; + +SHOW TABLES '*dim*|*fact*'; + +show files in sample_table partition (j < 5); + +show files in sample_table partition ( + k = 3, + l between 1 + and 10 +); + +show files in sample_table partition (month like 'J%'); + +show files in unpart_text; + +show partitions part_text; + +show files in s3_testing.sample_data_s3; + +show roles; + +show current roles; + +show tables in full_db like 'dim*'; + +show CREATE TABLE numeric_grades_default_letter; + +show range partitions numeric_grades_default_letter; + +show table stats kudu_table; + +show column stats customer; + +show functions in _impala_builtins; + +show functions in _impala_builtins like '*week*'; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/shutdown.sql b/test/parser/impala/syntax/fixtures/shutdown.sql new file mode 100644 index 0000000..7528927 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/shutdown.sql @@ -0,0 +1,14 @@ +-- :SHUTDOWN(); +:SHUTDOWN(); + +-- :SHUTDOWN([host_name[:port_number] ) +:SHUTDOWN("hostname:1234"); +:SHUTDOWN('hostname'); + +-- :SHUTDOWN(deadline) +:SHUTDOWN(0); +:SHUTDOWN(10); + +-- :SHUTDOWN([host_name[:port_number], deadline) +:SHUTDOWN('hostname', 10); +:SHUTDOWN('hostname:11', 10 * 60); diff --git a/test/parser/impala/syntax/fixtures/truncate_table.sql b/test/parser/impala/syntax/fixtures/truncate_table.sql new file mode 100644 index 0000000..0b143ab --- /dev/null +++ b/test/parser/impala/syntax/fixtures/truncate_table.sql @@ -0,0 +1,10 @@ +-- TRUNCATE [TABLE] [IF EXISTS] [db_name.]table_name +TRUNCATE my_table; +TRUNCATE my_db.my_table; +TRUNCATE TABLE my_table; +TRUNCATE IF EXISTS my_db.my_table; +TRUNCATE TABLE IF EXISTS my_db.my_table; + +-- example +TRUNCATE TABLE truncate_demo; +TRUNCATE TABLE IF EXISTS staging_table2; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/update.sql b/test/parser/impala/syntax/fixtures/update.sql new file mode 100644 index 0000000..45ad79c --- /dev/null +++ b/test/parser/impala/syntax/fixtures/update.sql @@ -0,0 +1,146 @@ +/* UPDATE [database_name.]table_name SET col = val [, col = val ... ] + [ FROM joined_table_refs ] + [ WHERE where_conditions ] */ +UPDATE + my_table +SET + col1 = 1, + col2 = 2, + col3 = 3; + +UPDATE + my_db.my_table +SET + col1 = 1; + +UPDATE + my_db.my_table +SET + col1 = 1 +WHERE + col2 = 1; + +UPDATE + my_db.my_table +SET + col1 = 1 +WHERE + col2 = 1 + AND col3 BETWEEN 100 + AND 300; + +UPDATE + my_table +SET + col1 = 'new_value' +FROM + other_table +WHERE + my_table.id = other_table.id; + +UPDATE + my_table +SET + col1 = ( + SELECT + MAX(col2) + FROM + other_table + WHERE + other_table.id = my_table.id + ) +WHERE + col3 = 'value'; + +UPDATE + my_table +SET + col1 = CASE + WHEN col2 > 10 THEN 'High' + WHEN col2 > 5 THEN 'Medium' + ELSE 'Low' + END +WHERE + col3 = 'value'; + +UPDATE + my_table +SET + col1 = ( + SELECT + AVG(col2) + FROM + other_table + WHERE + other_table.id = my_table.id + GROUP BY + other_table.id + ) +WHERE + col3 = 'value'; + +UPDATE + my_table +SET + col1 = other_table.val1 +FROM + my_table + JOIN other_table ON my_table.id = other_table.id +WHERE + my_table.col2 = 'value'; + +--example +UPDATE + kudu_table +SET + c3 = 'not applicable'; + +UPDATE + kudu_table +SET + c3 = NULL +WHERE + c1 > 100 + AND c3 IS NULL; + +UPDATE + kudu_table +SET + c3 = 'impossible' +WHERE + 1 = 0; + +UPDATE + kudu_table +SET + c3 = upper(c3), + c4 = FALSE, + c5 = 0 +WHERE + c6 = TRUE; + +UPDATE + kudu_table +SET + c3 = upper(c3) +FROM + kudu_table + JOIN non_kudu_table ON kudu_table.id = non_kudu_table.id; + +UPDATE + t1 +SET + c3 = upper(c3) +FROM + kudu_table t1 + JOIN non_kudu_table t2 ON t1.id = t2.id; + +UPDATE + t1 +SET + c3 = upper(c3) +FROM + kudu_table t1 + JOIN non_kudu_table t2 ON t1.id = t2.id +WHERE + c3 != upper(c3); \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/upsert.sql b/test/parser/impala/syntax/fixtures/upsert.sql new file mode 100644 index 0000000..a8253d4 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/upsert.sql @@ -0,0 +1,89 @@ +/* UPSERT [hint_clause] INTO [TABLE] [db_name.]table_name + [(column_list)] + { + [hint_clause] select_statement + | VALUES (value [, value ...]) [, (value [, value ...]) ...] + } */ +UPSERT INTO my_table +SELECT + id, + 'new_value1', + 'new_value2' +FROM + other_table +WHERE + condition; + +UPSERT -- +NOSHUFFLE -- +CLUSTERED +INTO my_table +/* +NOSHUFFLE */ +SELECT + id, + 'new_value1', + 'new_value2' +FROM + other_table +WHERE + condition; + +UPSERT INTO my_table -- +SHUFFLE +SELECT + id, + 'new_value1', + 'new_value2' +FROM + other_table +WHERE + condition; + +UPSERT INTO my_table (id, col1, col2) +SELECT + id, + 'new_value1', + 'new_value2' +FROM + other_table +WHERE + condition; + +UPSERT INTO TABLE my_db.my_table (id, col1, col2) +SELECT + id, + 'new_value1', + 'new_value2' +FROM + other_table +WHERE + condition; + +UPSERT INTO my_table (id, col1, col2) +VALUES + (1, 'new_value1', 'new_value2'), + (2, 'new_value3', 'new_value4'); + +UPSERT -- +NOSHUFFLE -- +CLUSTERED +INTO my_db.my_table +VALUES + (1, 'new_value1', 'new_value2'), + (2, 'new_value3', 'new_value4'); + +-- example +UPSERT INTO kudu_table (pk, c1, c2, c3) +VALUES + (0, 'hello', 50, true), + (1, 'world', -1, false); + +UPSERT INTO production_table +SELECT + * +FROM + staging_table; + +UPSERT INTO production_table +SELECT + * +FROM + staging_table +WHERE + c1 IS NOT NULL + AND c2 > 0; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/use.sql b/test/parser/impala/syntax/fixtures/use.sql new file mode 100644 index 0000000..599f796 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/use.sql @@ -0,0 +1,2 @@ +-- USE db_name +USE my_db; \ No newline at end of file diff --git a/test/parser/impala/syntax/fixtures/values.sql b/test/parser/impala/syntax/fixtures/values.sql new file mode 100644 index 0000000..4b380a0 --- /dev/null +++ b/test/parser/impala/syntax/fixtures/values.sql @@ -0,0 +1,10 @@ +-- VALUES (row)[, (row), ...]; +VALUES ('r1_c1', 'r1_c2', 'r1_c3'); +VALUES ('r1_c1', 'r1_c2', 'r1_c3'), ('r1_c1', 'r1_c2', 'r1_c3'); +VALUES ('r1_c1', 'r1_c2', 'r1_c3'), ('r1_c1', 'r1_c2', 'r1_c3'), ('r1_c1', 'r1_c2', 'r1_c3'); +VALUES ('r1_c1' as 'hi', 'r1_c2', 'r1_c3'), ('r1_c1', 'r1_c2', 'r1_c3' as 'hi'); + +-- example +VALUES(4,5,6),(7,8,9); +VALUES(1 AS c1, true AS c2, 'abc' AS c3), (100,false,'xyz'); +VALUES (CAST('2019-01-01' AS TIMESTAMP)), ('2019-02-02'); \ No newline at end of file diff --git a/test/parser/impala/syntax/insert.test.ts b/test/parser/impala/syntax/insert.test.ts new file mode 100644 index 0000000..425d6be --- /dev/null +++ b/test/parser/impala/syntax/insert.test.ts @@ -0,0 +1,18 @@ +import ImpalaSQL from '../../../../src/parser/impala'; +import { readSQL } from '../../../helper'; + +const parser = new ImpalaSQL(); + +const features = { + insert: readSQL(__dirname, 'insert.sql'), +}; + +describe('ImpalaSQL Insert Syntax Tests', () => { + describe('INSERT', () => { + features.insert.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); +}); diff --git a/test/parser/impala/syntax/otherStatement.test.ts b/test/parser/impala/syntax/otherStatement.test.ts new file mode 100644 index 0000000..1b403f3 --- /dev/null +++ b/test/parser/impala/syntax/otherStatement.test.ts @@ -0,0 +1,114 @@ +import ImpalaSQL from '../../../../src/parser/impala'; +import { readSQL } from '../../../helper'; + +const parser = new ImpalaSQL(); + +const features = { + computeStats: readSQL(__dirname, 'compute_stats.sql'), + comments: readSQL(__dirname, 'comment.sql'), + grants: readSQL(__dirname, 'grant.sql'), + revokes: readSQL(__dirname, 'revoke.sql'), + loadData: readSQL(__dirname, 'load_data.sql'), + describes: readSQL(__dirname, 'describe.sql'), + explains: readSQL(__dirname, 'explain.sql'), + invalidates: readSQL(__dirname, 'invalidate_metadata.sql'), + set: readSQL(__dirname, 'set.sql'), + shutdown: readSQL(__dirname, 'shutdown.sql'), + truncate: readSQL(__dirname, 'truncate_table.sql'), + use: readSQL(__dirname, 'use.sql'), + values: readSQL(__dirname, 'values.sql'), +}; + +describe('ImpalaSQL Other Syntax Tests', () => { + describe('COMPUTE STATS', () => { + features.computeStats.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('COMMENT STATEMENT', () => { + features.comments.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('GRANT STATEMENT', () => { + features.grants.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('REVOKE STATEMENT', () => { + features.revokes.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('LOAD DATA STATEMENT', () => { + features.loadData.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('DESCRIBE STATEMENT', () => { + features.describes.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('EXPLAIN STATEMENT', () => { + features.explains.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('INVALIDATE METADATA STATEMENT', () => { + features.invalidates.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('SET STATEMENT', () => { + features.set.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('SHUTDOWN STATEMENT', () => { + features.shutdown.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('TRUNCATE TABLE STATEMENT', () => { + features.truncate.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('USE STATEMENT', () => { + features.use.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('VALUES STATEMENT', () => { + features.values.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); +}); diff --git a/test/parser/impala/syntax/refresh.test.ts b/test/parser/impala/syntax/refresh.test.ts new file mode 100644 index 0000000..2167b4b --- /dev/null +++ b/test/parser/impala/syntax/refresh.test.ts @@ -0,0 +1,34 @@ +import ImpalaSQL from '../../../../src/parser/impala'; +import { readSQL } from '../../../helper'; + +const parser = new ImpalaSQL(); + +const features = { + refresh: readSQL(__dirname, 'refresh.sql'), + authorization: readSQL(__dirname, 'refresh_authorization.sql'), + function: readSQL(__dirname, 'refresh_function.sql'), +}; + +describe('ImpalaSQL Refresh Syntax Tests', () => { + describe('REFRESH', () => { + features.refresh.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('REFRESH AUTHORIZATION', () => { + features.authorization.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); + describe('REFRESH FUNCTION', () => { + features.function.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); +}); diff --git a/test/parser/impala/syntax/select.test.ts b/test/parser/impala/syntax/select.test.ts new file mode 100644 index 0000000..44fbcb5 --- /dev/null +++ b/test/parser/impala/syntax/select.test.ts @@ -0,0 +1,18 @@ +import ImpalaSQL from '../../../../src/parser/impala'; +import { readSQL } from '../../../helper'; + +const parser = new ImpalaSQL(); + +const features = { + select: readSQL(__dirname, 'select.sql'), +}; + +describe('ImpalaSQL Select Syntax Tests', () => { + describe('SELECT', () => { + features.select.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); +}); diff --git a/test/parser/impala/syntax/show.test.ts b/test/parser/impala/syntax/show.test.ts new file mode 100644 index 0000000..0a62b7c --- /dev/null +++ b/test/parser/impala/syntax/show.test.ts @@ -0,0 +1,18 @@ +import ImpalaSQL from '../../../../src/parser/impala'; +import { readSQL } from '../../../helper'; + +const parser = new ImpalaSQL(); + +const features = { + shows: readSQL(__dirname, 'show.sql'), +}; + +describe('ImpalaSQL Show Syntax Tests', () => { + describe('SHOW', () => { + features.shows.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); +}); diff --git a/test/parser/impala/syntax/update.test.ts b/test/parser/impala/syntax/update.test.ts new file mode 100644 index 0000000..c7b77e9 --- /dev/null +++ b/test/parser/impala/syntax/update.test.ts @@ -0,0 +1,18 @@ +import ImpalaSQL from '../../../../src/parser/impala'; +import { readSQL } from '../../../helper'; + +const parser = new ImpalaSQL(); + +const features = { + update: readSQL(__dirname, 'update.sql'), +}; + +describe('ImpalaSQL Update Syntax Tests', () => { + describe('UPDATE', () => { + features.update.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); +}); diff --git a/test/parser/impala/syntax/upsert.test.ts b/test/parser/impala/syntax/upsert.test.ts new file mode 100644 index 0000000..5af34e6 --- /dev/null +++ b/test/parser/impala/syntax/upsert.test.ts @@ -0,0 +1,18 @@ +import ImpalaSQL from '../../../../src/parser/impala'; +import { readSQL } from '../../../helper'; + +const parser = new ImpalaSQL(); + +const features = { + update: readSQL(__dirname, 'upsert.sql'), +}; + +describe('ImpalaSQL Upsert Syntax Tests', () => { + describe('UPSERT', () => { + features.update.forEach((db) => { + it(db, () => { + expect(parser.validate(db).length).toBe(0); + }); + }); + }); +}); diff --git a/test/parser/impala/visitor.test.ts b/test/parser/impala/visitor.test.ts new file mode 100644 index 0000000..eea43a8 --- /dev/null +++ b/test/parser/impala/visitor.test.ts @@ -0,0 +1,32 @@ +import impalaSQL from '../../../src/parser/impala'; +import { ImpalaSqlParserVisitor } from '../../../src/lib/impala/ImpalaSqlParserVisitor'; +import { AbstractParseTreeVisitor } from 'antlr4ts/tree'; + +describe('impala SQL Visitor Tests', () => { + const expectTableName = 'user1'; + const sql = `select id,name,sex from ${expectTableName};`; + const parser = new impalaSQL(); + + const parseTree = parser.parse(sql, (error) => { + console.log('Parse error:', error); + }); + + test('Visitor visitTableName', () => { + let result = ''; + class MyVisitor + extends AbstractParseTreeVisitor + implements ImpalaSqlParserVisitor + { + protected defaultResult() { + return result; + } + visitTableNamePath = (ctx): void => { + result = ctx.text.toLowerCase(); + }; + } + const visitor: any = new MyVisitor(); + visitor.visit(parseTree); + + expect(result).toBe(expectTableName); + }); +});